Introdução
O AVR32 é um novo núcleo RISC de 32 bits de alto desempenho para
microcontrolador, desenhado para aplicações embarcadas sensíveis
ao custo, com enfase em particular em baixo consumo e alto densidade
de código. Além disto, a arquitetura do conjunto
de instruções foi ajustado para permitir uma variedade de
microarquiteturas, permitindo que os processadores AVR32 implementem
baixo médio ou alto desempenho. O núcleo AVR32 extende a família
AVR para o mundo das aplicações de 32 e 64 bits.
A família AVR32
A família AVR foi lançado pela Atmel em 1996 e
teve um sucesso notável no mercado de microcontroladores com flash
de 8 e 16 bit. Através da família AVR32, o AVR é extendido em uma
nova gama de aplicações de maior desempenho que atualmente é
servido por processadores de 32 e 64 bits. Para explorar
verdadeiramente o poder de uma arquitetura de 32 bit, a nova
arquitetura AVR32 não é binariamente compatível com as
arquiteturas AVR anteriores isto é, não é compatível com as
arquiteturas de 8 e 16 bits. De forma a atingir a densidade de código
elevado, o formato da instrução é flexível, oferecendo instruções
de ambas comprimentos: compactas de 16 bits e estendidas de 32 bits.
Enquanto o comprimento das instruções é de apenas 16 bits para a
maioria das instruções, as potentes instruções de 32 bits são
implementadas para aumentar ainda mais o desempenho. Instruções
compactas e estendida podem ser livremente misturado no fluxo de
instruções.
A Arquitetura AVR32
O AVR32 é uma nova e inovador arquitetura de
microprocessadores. É um projeto totalmente sintetizado e
sincronizado com interfaces padrão da indústria, garantindo uma
fácil integração em projetos de solução em solução em um
circuito integrado com o legado da propriedade intelectual. Através
de uma abordagem quantitativa, um grande conjunto de reconhecidos
parâmetros da indústria foram compilados e analisados para obter o
melhor na sua densidade de código nesta classe de arquiteturas de
microprocessadores. Além disso, para reduzir os
requisitos de memória, um código de tamanho compacto, também
contribui para as características do núcleo de baixa potência. O
processador suporta os tipos de dados byte e meia palavra sem
penalidade no tamanho do código e no desempenho. Operações
de armazenamento e leitura de memória são fornecidas para dados do
tipo byte, meia palavra, palavra e dupla palavra com extensão
automática extensão de sinal ou zero para dados de meia-palavra e
bytes. O compilador C está intimamente
ligada à arquitetura
e é capaz de explorar recursos optimização do código tanto para o
tamanho quanto para a
velocidade. A fim de
reduzir o tamanho do código para um mínimo, algumas instruções
têm múltiplos modos de endereçamento. Como um exemplo, instruções
com imediatos muitas vezes têm um formato compacto com uma menor
imediato e uma estendida com um formato imediato maior. Desta forma,
o compilador é capaz de utilizar o formato dando o menor tamanho de
código. Uma outra característica do conjunto de instruções é que
as instruções frequentemente utilizados, como adicionar, têm um
formato compacto com dois operadores, bem como um formato estendido
com três operandos. O formato maior aumenta o desempenho, permitindo
uma adição e um movimento de dados na mesma instrução num único
ciclo. As instruções de carregar e armazenar têm vários formatos
diferentes, a fim de reduzir o tamanho do código e acelerar a
execução:
- armazena/restaura para um endereço especificado por um registrador ponteiro
- armazena/restaura para um endereço especificado por um registrador ponteiro com pré incremento
O arquivo de registradores são organização em registradores de 16
e 32 bits e incluem o contador de programa, o registrador de ligação
e o apontador da pilha. Além disso, um
registrador é destinado a manter os valores de retorno de chamadas
de função e é usado implicitamente por algumas instruções. O
núcleo AVR32 define várias microarquiteturas a fim de captar toda a
gama de aplicações. Os microarquiteturas são nomeados AVR32A,
AVR32B e assim por diante. Diferentes microarquiteturas são
adequados para aplicações finais diferentes, permitindo ao
projetista selecionar uma microarquitetura com o melhor conjunto de
parâmetros para uma aplicação específica.
Exceção e interrupção
O AVR32 incorpora um poderoso esquema de
manipulação de exceção. As diferentes fontes de exceção, como
código ilegal e pedidos de interrupção externos, têm diferentes
níveis de prioridade, garantindo um comportamento bem definido
quando várias exceções são recebidas simultaneamente. Além
disso, as exceções de uma classe de maior prioridade pendente pode
antecipar a manipulação de exceções em curso de uma classe de
menor prioridade. Cada classe de prioridade tem um registrador
dedicado à manter o endereço de retorno e o registrador de estado
eliminando assim a necessidade de realizar operações de memória
que consomem tempo para salvar esta informação. Existem quatro
níveis de pedidos de interrupção externos, todos executados em seu
próprio contexto. Os contextos podem fornecer um número de
registradores dedicados para as interrupções usados diretamente
assegurando baixa latência.
Interrupções de alta prioridade podem ter um
maior número de registradores de sombra disponíveis do que a interrupção
de baixa prioridade. Um controlador de interrupção faz o tratamento
prioritário das interrupções externas e fornece o vetor de
interrupção de prioridade para o núcleo do processador.
Suporte a Java
Java hardware acceleration is available as an option, in the form of
a Java Card or Java Virtual
Machine hardware implementation.
Aceleração de hardware Java está disponível
como uma opção, na forma de implementação Java Card ou máquina
virtual Java.
Segurança
A revisão 3 da arquitetura AVR32 introduziu um
novo estado da UCP chamado Estado Seguro. Este estado é fundamental
para a nova tecnologia de segurança chamado FlashVault. Essa
inovação permite que o flash interna e outras memórias a ser
parcialmente programadas e bloqueado, criando um armazenamento
interno de segurança para o código secreto e para os programas de
propriedade intelectual valioso. Código armazenado no FlashVault irá
executar normal, mas a leitura, a cópia ou a depuração do código
não é possível. Isso permite que um dispositivo com proteção de
código FlashVault possa ter um pedaço de programa valioso, como uma
biblioteca de matemática ou um algoritmo de criptografia de um local
confiável a um parceiro potencialmente não confiável, enquanto o
resto do código-fonte pode ser desenvolvido, depurado e programado.
Microarquitetura
A arquetura AVR32 define diferentes microarquiteturas. Isso
permite implementações que são adaptados às necessidades e
aplicações específicas. Os microarquiteturas fornecem diferentes
níveis de desempenho em detrimento da área e consumo de energia. Os
seguintes microarquiteturas são definidos:
AVR32A
A microarquitetura AVR32A é destinado a aplicações sensíveis ao custo, baixa-end, assim como microcontroladores menores. Esta microarquitetura não fornece hardware dedicado registradores para sombreamento do arquivo de registradores no contextos de interrupção. Além disso, ela não fornece registradores para endereço de retorno e registrador de estado. Em vez disso, toda esta informação é armazenada na pilha do sistema. Isto poupa área de pastilha, a dispensa o tratamento de interrupções mais lento. Após o início de interrupção, registradores R8-R12 são automaticamente empurrados para a pilha do sistema. Estes registos são empurrados, independentemente do nível de prioridade da interrupção pendente. O endereço de retorno e registrador de estado também são enviadas automaticamente para a pilha. O manipulador de interrupção pode, portanto, usar R8-R12 livremente. Após a conclusão da interrupção, as velhos registradores R8-R12 e registrador de estado são restaurados, e a execução continua no endereço de retorno armazenado puxado da pilha. A pilha também é usado para armazenar o registrador de estado e o endereço de retorno para exceções e scall. Executar a instrução rete ou rets na conclusão de uma chamada de exceção ou sistema irá registrar esse estado e continuar a execução puxando o endereço de retorno.AVR32B
A microarquitetura AVR32B é destinado a
aplicações onde a latência de interrupção é importante. Por isso, o AVR32B implementa registradores
dedicados para manter o registrador de estado e endereço de retorno
das interrupções, exceções e supervisor de chamadas. Estas
informações não são necessárias serem escritas na pilha, e
portanto a latência é reduzida. Além disso, o AVR32B permite o
hardware de sombreamento dos registradores no arquivo de
registradores. As INT0 até a INT3 contextos podem ter dedicado
versões dos registradores no arquivo de registrador, permitindo que
a rotina de interrupção inicie a execução imediatamente. As
instruções scall, rete e rets usam registradores dedicado para
registrar o estado e endereços de retorno em sua operação. Nenhum
acesso a pilha são executadas.
Estados do processador
É
definido três estados aceitos pelo processador dependendo da versão
da eletrônica, que são:
- normal
- depuração
- Java
- seguro
Estado normal RISC
O processador AVR32 suporta vários contextos de execução
diferentes.
O
modo de alterações podem ser feitas sob controlo de programa, ou
pode ser causada por uma interrupções externas ou uma exceção no
processamento. Um modo pode ser interrompido por um modo de
prioridade mais elevada mas nenhum com menor prioridade. Exceções
aninhadas podem ser suportadas com uma sobrecarga mínima de
programa.
Ao executar um sistema operacional no AVR32 os processos de usuário normalmente executam no modo de aplicação. Os programas executados nesta modalidade são impedidos de executar certas instruções. Além disso, a maioria dos registradores do sistema juntamente com a meia palavra superior do registrador de estado não podem ser acessado. Áreas de memória protegidas também não estão disponíveis. Todos os outros modos de funcionamento são privilegiados e são chamados coletivamente de “modos do sistema”. Eles têm pleno acesso a todos os recursos privilegiados e sem privilégios. Depois de um reinício o processador estará no modo supervisor.
Estado de depuração
O
AVR32 pode ser configurado para o estado de depuração, que permite
a implementação de rotinas de monitor de programa que, por sua vez,
pode ler e alterar as informações do sistema para ser usadas no
desenvolvimento do aplicativo. Isto implica que todos os sistemas e
registradores dos aplicativos, incluindo os registradores de estado e
o contador de programa são acessíveis no estado de depuração. As
instruções privilegiadas também estão disponíveis.
Todos os níveis de interrupção são desativadas por padrão quando
o estado de depuração for definido mas eles podem ser
individualmente ligados pela rotina do monitor limpando a respectiva
máscara de bit no registrador de estado. O estado depuração é
encerrado pela instrução RETD. O estado de depuração pode ser
definido seguindo as informações descritas no manual de referência
técnica da eletrônica (hardware).
Estado Java
Algumas versões do núcleo do processador AVR32 vem com um módulo
de extensão Java (JEM). O processador pode ser definido no estado
Java onde as operações RISC normais são suspensas.
Estado seguro
O
estado seguro adicionado na arquitetura AVR32 revisão 3 permite a
execução no mesmo processador de um programa seguro ou confiável
e/ou um programa não seguro ou não confiável. O mecanismos de
eletrônica estão implantados para garantir que o programa não
seguro ou não confiável não possa ler ou modificar instruções ou
dados pertencentes ao programa seguro ou confiável.
Mecanismo de entrar e sair dos modos
São vários formas de entrar e sair nos modos aceitos.
Arquivo de registradores
Cada um dos modos normais de operação do AVR32
tem um contexto específico. Note-se que o ponteiro de pilha (SP),
contador de programa (PC) e o registrador de ligação (LR) são
mapeados no arquivo de registradores, formando o conjunto efetivos de
registradores logo terão 13 registradores de propósito geral para
cada contexto. O mapeamento de SP, PC e LR permite instruções
comuns, como adições ou subtrações, para usar esses
registradores. Isto resulta em abordagem eficiente da memória. O
registrador R12 é projetado para manter os valores de retorno das
funções de chamadas, e do retorno condicional com movimento e
instrução de teste logo, este registrador é usado como um valor
implícito de retorno do operando. As instruções de carga múltiplas
(load) e empurra múltiplas (pop) têm a mesma funcionalidade, que
permite que eles sejam usados como instruções de retorno. Conjunto
de instruções ortogonais do núcleo AVR32 permite que todos os
registradores no arquivo de registradores possam ser usado como
ponteiros.
Arquivo de registradores no AVR32A
O
AVR32A é voltado para aplicações sensíveis ao custo. Portanto,
nenhum hardware de sombreamento de registradores é fornecido. Todos
os dados que devem ser guardados entre os estados de execução são
colocados na pilha do sistema, não nos registos dedicados como feito
no AVR32B. A apontador de pilha sombreado ainda está disponível
para os modos privilegiados, facilitando um sistema de pilha
dedicado.
Quando ocorre uma exceção em uma implementação compatível
AVR32A, o registrador de estado e o endereço do remetente são
empurrados por hardware para a pilha do sistema. Quando um INT0,
INT1, INT2 ou INT3 ocorre, o registrador de estado, endereço de
retorno, R8, R12 e LR são empurrados para a pilha do sistema. Os
registradores correspondentes são puxados da pilha pela instrução
RETE. As instruções SCALL e RETS também usam a pilha do sistema
para armazenar o endereço de retorno e registrador de estado.
Arquivo de registradores no AVR32B
O
AVR32B permite que os arquivos de registradores em separado para os
modos de interrupção e de exceção.
Estes modos têm uma série de implementações
definindo os registradores de sombra, a fim de acelerar o tratamento
de interrupção. Os registradores de sombra são automaticamente
mapeados dependendo do modo de execução.
Todos os contextos, com exceção dos aplicativos,
tem um o Registrador de estado (RSR) dedicado de retorno e um
registrador de endereço de retorno (RAR). Os registradores RSR são
usados para armazenar o valor do registrador de estado no contexto de
retorno. Os registradores RAR são usados para armazenar o endereço
no contexto de retorno. Os registradores RSR e RAR eliminam a
necessidade de armazenar temporariamente o registrador de estado e o
endereço e retorno da pilha ao entrar no novo contexto.
O arquivo de registrores é projetado com uma parte específica de
implementação e uma parte arquitetônico definido. Dependendo da
implementação, cada um dos modos de interrupção pode ter
diferentes configurações de registradores sombreados. Isto permite
a máxima flexibilidade no direcionamento do processador para
aplicações diferentes.
Apontador da pilha
Desde que o SP está locado no
arquivo de registradores, ele pode ser endereçado como um
registrador comum. Isto simplifica a alocação e o acesso das
variáveis locais e parâmetros. O ponteiro de pilha também é usado
implicitamente por várias instruções. Os modos de sistema tem um
ponteiro de pilha sombreado diferente do ponteiro da pilha no modo de
aplicação. Isto permite ter uma separação da pilha do sistema.
O
contador de programa (PC) está mapeado no arquivo de registradores e pode
ser usado como uma fonte ou destino do operando em todas as
instruções usando registradores de operandos. Isso inclui
instruções aritméticas ou lógicas e instruções de carga /
descarga. Instruções usando PC como registrador destino são
tratados da mesma maneira como as instruções de salto. Isto implica
que o pipeline é nivelada/lavada (flushed) e a execução retomado
no endereço indicado pelo novo valor do PC.
O
registrador de uso geral R14 é usado como registrador de ligação –
LR, em todos os modos. O registrar de ligação mantém os endereços
de retorno de sub-rotinas. Quando uma chamada de subrotina é
realizada por uma variante da instrução de chamada, LR é definido
para conter o endereço de retorno da subrotina. A sub-rotina de
retorno é realizado copiando LR de volta para o contador do
programa, quer explicitamente por uma instrução MOV, usando um LDM
ou instrução POPM ou uma instrução de RET. No registrador de link
R14 pode ser usado como um registrador de propósito geral em todas
as outras vezes.
O contador de programa
O
contador do programa (PC) contém o endereço das instruções serem
executadas. O espaço de memória é byte endereçado. Com a exceção
do estado de Java, o tamanho da instrução é um múltiplo de 2
bytes e o LSB do contador de programa é fixado em zero. O PC é
incrementado automaticamente em fluxo normal do programa, dependendo
da dimensão da instrução corrente.
O PC está mapeado no arquivo de registradores e pode ser usado como
um operando fonte ou um destino em todas as instruções que usam
registradores como operandos. Isso inclui instruções aritméticas
ou lógicas e instruções de carga/descarga. Instruções usando PC
com registrador de destino são tratados da mesma maneira como as
instruções de salto.
O registrador de ligação
O registrador de propósito geral R14 é usado como um registrador de
ligação – LR, em todos os modos. O LR mantém o endereços de
retorno das sub-rotinas. Quando uma chamada de sub-rotina é
realizada por uma variante da instrução CALL, LR é definido para
conter o endereço de retorno da sub-rotina. A sub-rotina de retorno
é realizado copiando LR de volta para o PC, quer explicitamente por
uma instrução MOV, usando um LDM ou instrução POPM ou uma
instrução de RET. O LR (R14) pode ser usado como um registrador de
propósito geral em todas as outras vezes.
O registrador de estado
O registrador de estado (SR) é dividido em duas meias palavras, uma
superior e uma inferior. A meia palavra inferior contém os seguintes
indicadores: C, Z, N, V e Q, enquanto a meia palavra superior contém
informações sobre o modo e estado do processador atuais. A meia
palavra superior só pode ser acessada a partir de um modo
privilegiado.
Registradores do sistema
Os registradores do sistemas são colocados fora do espaço de
memória virtual, e só são acessíveis através do MFR privilegiada
e instruções MTSR. O número de locais físicos é a implementação
definida, mas um máximo de 256 locais podem ser tratadas com as
instruções dedicados. Alguns dos registradores do sistema são
alterados automaticamente pelo hardware. O valor de reposição dos registradores do sistema são definidos pela implementação.
Configuração dos Registradores
A
configuração dos registradores são usados para informar os
aplicativos e os sistemas operacionais sobre a instalação e
configuração do processador no qual ele está sendo executado. O
AVR32 implementa somente a leitura dos registradores de configuração.
Convenção recomendado na chamada
O fornecedor de compilador é livre para definir uma convenção de
chamada, mas visto de um ponto de vista do hardware, existem algumas
recomendações sobre como a convenção de chamada deve ser
definido. O registrador R12 é concebida como registrador de retorno
do valor em conexão com as chamadas de função. Algumas instruções
usará esse registrador de forma implícita. Por exemplo, a instrução
condicional RET vai passar o seu argumento em R12.
Estado seguro
A
revisão 3 da arquitetura AVR32 introduz um estado de execução
segura. Este estado se destina a permitir a execução de um código
de propriedade secreta juntamente com um código de origem
desconhecida e o processador com a mesmo intenção. Por exemplo, uma
empresa com um algoritmo proprietário pode programar este algoritmo
para as secções do dispositivo de memória segura, e revender o
aparelho com o algoritmo programado para um cliente final. O cliente
final não será capaz de ler ou modificar o código pré-programados
de qualquer maneira.
Exemplos deste tipo de código pré-programado pode ser o codecs
multimídia, algoritmos de processamento digital de sinais ou pilhas
de programas de telecomunicações. Considerando as abordagens
anteriores para este problema requeriam o código proprietário e
aplicação do usuário final para executar em dispositivos
separados, o estado seguro permite a integração dos dois códigos
no mesmo dispositivo, redução de custos e aumentando o desempenho,
pois a comunicação entre circuitos não é mais necessário.
A fim de manter o código proprietário em segredo, este código será
executado em um "mundo seguro". O aplicativo do usuário
final irá executar em um "mundo não segura". O código do
mundo não seguro pode solicitar serviços do mundo seguro,
executando uma instrução especial, SSCALL.
Esta instrução é executada no contexto de uma
API especificada pelo fornecedor do código proprietário. A
instrução SSCALL pode ser associado aos argumentos passados em
registradores ou memória, e após a execução do algoritmo
solicitado, o mundo seguro retorna os resultados para o pedido da
aplicação não segura em registradores ou na memória.
O
hardware é implementado para dividir os recursos de memória em duas
seções: uma seção não segura e uma secção segura. A seção de
memória segura só pode ser acessada (leitura, escrita ou execução)
pelo código executando no mundo seguro. A seção de memória não
segura pode ser lido, escrito ou executado a partir do mundo não
segura, e lido ou escrito do mundo seguro.
O cliente pode escolher se sua aplicação
permitirá que o estado seguro ou não. Um mecanismo de implementação
definido, geralmente um fusível Flash, é usado para ativar ou
desativar o suporte ao estado seguro.
Se esse mecanismo é programado de forma a
desativar o estado seguro, o sistema irá arrancar no mundo não
segura, e seu comportamento será idêntico aos dispositivos
anteriores implementando as revisões antigas da arquitetura AVR32
executando.
Se o sistema estiver configurado para ativar o suporte ao estado
seguro, o sistema irá arrancar no estado seguro. Isso permite que a
configuração e inicialização do aplicativo seja no mundo seguro
antes da execução ser passada para o mundo não seguras.
Mecanismos de implementação do estado seguro
- As interrupções e exceções têm manipuladores endereços especiais usadas no recebimento as interrompições ou exceções no mundo seguro. Isso permite executar a interrupção ou manipulador de exceção no mundo seguro, ou saltar de volta ao mundo não segura para executar o manipulador de lá.
Modelo de programação estado seguro
O modelo de programação no estado seguro é semelhante no estado
RISC normal, exceto que SP_SEC foi depositado (banked), e os
registradores do sistema de segurança estão disponíveis em todos
os modos de privilegiados.
Detalhes sobre a implementação Estado Seguro
Consulte o
manual de referência técnica para o núcleo da UCP que você está
usando para obter detalhes sobre a implementação de estado de
segurança.
Unidade de Gerenciamento de Memória
A arquitetura AVR32 define uma unidade de
gerenciamento de memória opcional (MMU). Isso permite a
implementação eficiente da memória virtual e grandes espaços de
memória. A memória virtual simplifica a execução de vários
processos e permite a alocação de privilégios a diferentes secções
para o espaço de memória.
A arquitetura AVR32 especifica um espaço de memória virtual de 32
bits. Este espaço virtual é mapeado em um espaço físico de 32
bits por MMU. Também deve ser notado que nem todas as implementações
usará caches. As informações cacheability são especificadas na
figura, portanto, não se aplicam para todas as implementações.
Consulte a aplicação específica no manual de Hardware para mais
detalhes.
Mapa de memória em sistemas com MMU
A arquitetura AVR32 especifica um espaço de memória virtual de 32
bits. Este espaço virtual é mapeado em um espaço físico de 32
bits por um MMU. Também deve ser notado que nem todas as
implementações usará caixas. As informações caixiáveis
especificado na figura, portanto, não se aplicam para todas as
implementações. Consulte o Manual de Hardware aplicação
específica para mais detalhes.
O mapa de memória tem seis segmentos distintos,
denominados P0 a P4, e U0. O P-segmentos são acessíveis nos modos
privilegiados, enquanto que o segmento de U está acessível no modo
sem privilégios.
A tradução do segmento pode ser desativada,
limpando o bit S no MMUCR. Isto irá colocar todo o espaço de
memória virtual mapeada em um único espaço de memória de 4 GB.
Fazendo isso vai dar todo o controle de permissão de acesso aos bits
AP na entrada da tabela TLB correspondente ao endereço virtual, e
permitir que todos os endereços virtuais possam ser traduzido. A
tradução do segmento é ativada por padrão. A arquitetura AVR32
tem duas traduções de endereços:
- por segmentação
- por páginação
A
tradução por segmento é habilitada pelo bit MMUCR [S] e a tradução
por página é habilitado pelo MMUCR [E] bit.
Ambas as traduções são executadas pelo MMU e elas podem ser
aplicadas independentemente umas das outras. Isso significa que você
pode ativar:
A tradução por segmento é, por padrão ativado e a tradução por
página é desativada por padrão após a reinicialização.
Compreendendo a MMU
A Unidade de gerenciamento de de memória (MMU) do AVR é responsável
pelo mapeamento virtual para endereços físicos. Quando um acesso à
memória é executada, o MMU traduz o endereço virtual especificado
para um endereço físico, enquanto verifica as permissões de
acesso.
Se ocorrer um erro no processo de tradução, ou uma intervenção do
sistema operacional for necessário, por algum motivo, a MMU emitirá
uma excepção, permitindo que o problema seja resolvido pelo
programa.
A arquitetura MMU usa paginação para mapear páginas de memória no
espaço de endereço virtual de 32 bits em um espaço de endereço
físico de 32 bits. Os tamanhos das páginas são de 1, 4, 64
kilobytes e 1 megabyte são suportados. Cada página tem direito de
acesso individual, proporcionando granularidade fina na proteção.
A informação necessária para executar o mapeamento virtual para
físico reside em uma tabela de página. Cada página tem sua própria
entrada na tabela de página. A tabela da página também contém
informações de proteção e outros dados necessários no processo
de tradução. Conceitualmente, a tabela de páginas é acessada para
cada acesso à memória, a fim de ler as informações de mapeamento
para cada página.
A fim de acelerar o processo de tradução, um cache de tabela de
página especial é usado. Esse cache é chamada de memória de
tradução trava um lado (Tradução Lookaside Buffer - TLB). O TLB
contém a n página mais recentemente utilizadas na entradas da
tabela de página. O número n de entradas na tabela TLB é definido
pela implementação.
Também é definido pela implementação se um único unificado TLB
deve ser utilizado tanto para instrução e acessos à memória, ou
se dois TLBs separados são implementadas. A arquitetura suporta um
ou dois TLBs com até 64 entradas cada. Entradas TLB também pode ser
bloqueado na TLB, garantindo acessos à memória de alta velocidade.
Modelos de memória virtual
A MMU fornece dois modelos diferentes de memória virtual,
selecionados pela bit modo (M) no registrador de controle da MMU:
- compartilhada
- privada
A memória virtual compartilhada é onde o mesmo espaço de endereço
virtual é compartilhada entre todos os processos.
Na memória virtual compartilhada, o endereço virtual identifica
qual o endereço físico deve ser mapeado. Dois processos diferentes
que tratam do mesmo endereço virtual irão sempre acessar o mesmo
endereço físico.
Em outras palavras, a secção do número de página virtual (VPN)
para o endereço virtual especifico e exclusivamente na secção
de número da estrutura física (PFN) no endereço físico.
A
memória virtual privada é onde cada processo tem seu próprio
espaço de endereço virtual. Na memória virtual privada, cada
processo tem seu próprio espaço de memória virtual. Isso é
implementado usando tanto o VPN e o Espaço Identificador de
Aplicação (ASID) do processo atual, quando pesquisando na TLB para
uma partida. Cada processo tem uma ASID única. Portanto, dois
processos diferentes acessam o mesmo VPN não vai bater a mesma
entrada TLB, desde que a sua ASID for diferente. As páginas podem
ser compartilhados entre os processos no modo virtual privada,
definindo o bit global (G) na entrada da tabela da página. Isso irá
desativar a verificação ASID na busca na TLB, causando a secção
VPN exclusivamente para identificar a PFN para a página particular.
Unidade de Proteção de memória
A
arquitetura AVR32 define uma unidade de proteção da memória
opcional (MPU). Isto é uma alternativa mais simples para uma MMU
completa, enquanto que ao mesmo tempo permiti a proteção da
memória. O MPU permite ao utilizador dividir o espaço de memória
em regiões de proteções diferentes. Estas regiões de proteção
tem um tamanho definido pelo usuário, e começa em um endereço
definido pelo usuário. As diferentes regiões podem ter diferentes
atributos cacheability e bufferability. Cada região está dividida
em 16 sub-regiões, cada uma destas sub-regiões podem ter um dos
dois conjuntos possíveis de permissões de acesso. O MPU não
realiza nenhuma conversão de endereço.
Mapa de memória em sistemas com MPU
Uma Implementação AVR32 com MPU tem um espaço
de memória plana, não segmentado. As permissões de acesso são
dadas apenas pelas diferentes regiões de proteção.
Compreendendo a MPU
A Unidade de Proteção de memória AVR32 (MPU) é
responsável em verificar nas transferências de memória se as
permissões estão corretas para ser concluído. Se um acesso à
memória com privilégios insatisfatórios é tentada, uma exceção
é gerada e o acesso é abortada. Se um acesso a um endereço de
memória que não residir em qualquer região de proteção é
tentada, uma exceção é gerada e o acesso é abortada.
O usuário é capaz de permitir diferentes níveis de privilégio
para diferentes blocos de memória, configurando um conjunto de
registradores. Cada bloco é chamado de região de protecção.
Cada
região tem um endereço inicial programável pelo usuário e
tamanho. O MPU permite ao usuário programar 8 regiões de proteção
diferentes. Cada uma destas regiões tem 16 sub-regiões, que podem
ter diferentes permissões de acesso, cacheability e bufferability.
Os contadores de desempenho
Visão global
Um
conjunto de contadores de desempenho que permite aos usuários
avaliar o desempenho do sistema. Isto é útil ao agendar o código e
realizando otimizações. Dois contadores de eventos configuráveis
são apresentados, juntamente com um contador de ciclo de relógio.
Estes
três contadores podem ser usados para coletar informações sobre,
por exemplo, as taxas de falha na cache, taxa de acerto de previsão
de ramificação e ciclos protelação do acaso de dados.
Os três marcadores são implementados como registradores de 32 bits acessíveis através do sistema de registradores de interface. Eles podem ser configurados para emitir um pedido de interrupção no caso de descarga, permitindo que um contador de transbordamento de programa a ser executado seja implementado.
Um
registrador de controle de desempenho do contador é aplicado, para
além dos três registradores do contador. Iste registrador controla
quais eventos serão gravados no contador, habilitação da
interrupção do contador de estouro e outros dados de configuração.
Processamento de Eventos
Devido a várias razões, a UCP pode ser obrigada a abortar a execução do programa normal, a fim de lidar com eventos especiais, de alta prioridade. Quando o tratamento destes eventos estão concluídos, a execução do programa normal pode ser retomado. Tradicionalmente, os eventos que são gerados internamente na UCP são chamados exceções, enquanto que os eventos gerados por fontes externas à UCP são chamadas de interrupções.
O
AVR32 tem um esquema de manipulação de eventos poderosa.
As diferentes fontes de eventos, como opcode ilegal e pedidos de
interrupção externos, têm diferentes níveis de prioridade,
garantindo um comportamento bem definido, quando vários eventos são
recebidos simultaneamente. Além disso, eventos de uma classe de
maior prioridade pendente pode antecipar a manipulação dos
acontecimentos em curso de uma classe de menor prioridade.
Quando ocorre um evento, a execução da instrução
é parada, e controle da execução é transmitido para um
processador de eventos num endereço especificado.
A maioria dos manipuladores são colocadas
sequencialmente no espaço de código que começam no endereço
especificado pelo EVBA, com quatro bytes entre cada manipulador. Isto
dá um amplo espaço para uma instrução de salto para ser aí
colocado, saltar para a própria rotina evento.
Alguns manipuladores críticos têm espaçamento maior entre eles,
permitindo que toda a rotina do evento pode ser colocado diretamente
no endereço indicado pelo EVBA - deslocamento relativo gerado pelo
hardware.
Todas as fontes de interrupção externas têm os endereços de
rotina de serviço de interrupção (ISR) autovetoriadas. Isso
permite que o controlador de interrupção especifique diretamente o
endereço ISR como um endereço em relação ao EVBA.
A gama de endereço acessível por este
deslocamento autovetoriado é definido pela implementação.
Implementações podem requerer EVBA a serem alinhadas na definida
implementação de forma a realizar a ordem definida de apoiar
autovetorada.
Os
mesmos mecanismos são usados para atender a todos os diferentes
tipos de eventos, incluindo pedidos de interrupção externas,
gerando um esquema de manipulação de eventos uniforme. Se o
aplicativo estiver em execução no estado seguro, o tratamento de
evento é modificado conforme explicado em "Manipulação de
eventos no estado seguro". Isso é para proteger o código de
segurança de hackers usando o sistema de eventos.
Manipulação de eventos em AVR32A
Exceções e pedidos de interrupção
Quando
um pedido do evento diferente SCALL ou DEBUG é recebido pelo núcleo,
as seguintes ações são executadas atomicamente:
- O evento pendente não será aceito se estiver mascarado. O I3M, I2M, I1M, I0M, EM e o bigt GM no registrador de estado são usados para mascarar eventos diferentes. Nem todos os eventos podem ser mascarado. Alguns eventos críticos como NMI, exceção irrecuperável, múltiplo colisão TLB e erro barramento não podem ser mascarados. Quando um evento é aceito, o hardware define automaticamente os bits da máscara correspondentes a todas as fontes, com prioridade igual ou menor. Isso inibe a aceitação de outros eventos de igual ou menor prioridade, exceto para os eventos críticos listados acima. O programa pode escolher apagar alguns ou todos estes bits após guardar o estado necessário se outros esquemas de prioridade são desejados. É responsabilidade da origem do evento garantir que seus eventos sejam deixados pendentes até o aceite pela UCP.
- Quando um pedido for aceito, o registrador de estado e contador de programa no contexto atual é armazenado na pilha do sistema. Se o evento for uma INT0, INT1, INT2 ou INT3, os registradores R8 a R12 e o LR também são armazenados automaticamente na pilha. Armazenar o registrador de estado garante que o núcleo é devolvido no modo de execução anterior, quando a manipulação do tratamento de eventos está concluída. Quando ocorrem exceções, tanto o EM e bit GM estão definidos, e a aplicação pode habilitar manualmente as próximas exceções, se desejar, limpando o bit apropriado. Cada manipulador de exceção tem um endereço manipulador dedicado, e este endereço identifica a fonte de exceção.
- Os bits são definidos de modo a refletir qual prioridade do evento estão aceitos e o qual o banco de registradores estão devidamente selecionados. O endereço do processador de eventos é carregado no contador de programa. A execução da rotina de manipulador de eventos, em seguida, continua a partir do endereço efetivo calculado.
A instrução RETE sinaliza o fim do evento.
Quando encontrado, o registrador de estado e registrador do endereço
de retorno são puxados da pilha do sistema e restaurados no
registrador de estado e no contador de programa. Se a instrução de
retorno – RETE for INT0, INT1, INT2 ou INT3, os registradores R8 a
R12 e LR também serão puxados da pilha do sistema. O registrador de
estado restaurado contém informações que permitem o núcleo
retomar a operação no modo de execução anterior. Isto conclui a
manipulação de eventos.
Chamadas do supervisor
O conjunto de instruções AVR32 fornece uma instrução de chamada
no modo supervisor. A instrução SCALL é projetado de modo que as
rotinas privilegiados podem ser chamado a partir de qualquer
contexto. Isso facilita o compartilhamento de código entre
diferentes modos de execução.
O
mecanismo SCALL é projetado para que haja um mínimo de sobrecarga
do ciclo de execução é experimentado quando realizado uma chamada
de rotina de supervisor num manipuladores de eventos com tempo
crítico.
A instrução SCALL comporta-se de forma diferente dependendo do modo
que ele é chamada. O comportamento é detalhado na referência do
conjunto de instruções. A fim de permitir que a rotina SCALL
retorne o contexto correto, uma instrução de chamada de retorno do
supervisor, RETS, é implementada. Na microarquitetura AVR32A, SCALL
e RETS usa a pilha do sistema para armazenar o endereço de retorno e
o registrador de estado.
Solicitações de depuração
A arquitetura AVR32 define um modo de depuração dedicado. Quando um
pedido de depuração é recebido pelo núcleo, o modo de depuração
é aceito. Entrada no modo de depuração pode ser mascarado pela bit
DM do registrador de estado. Após a entrada no modo de depuração,
o hardware define o bit D do SR e salta para o manipulador de exceção
de depuração. Por padrão, o modo de depuração executado no
contexto de exceção, mas com endereço de retorno e registrador de
estado dedicados. Estes registradores dedicados eliminam a necessidade de
armazenar esses dados na pilha do sistema, melhorando desse modo a
debugação. Os bits de modo no registrador de estado podem ser
livremente manipulados no modo de depuração, para observar os
registradores em todos os contextos, enquanto mantém todos os
privilégios. O modo de depuração é encerrado ao executar a
instrução RETD. Isto retorna o contexto anterior.
...
Pontos de entrada para eventos
Existe vários pontos de entrada para os diferentes manipuladores de
eventos. Para AVR32A, a rotina de reinício é endereçada em
0x8000_0000. Isso coloca o endereço de reinício na área de memória
flash. Para AVR32B, o endereço de entrada da rotina de reinício é
sempre fixado em 0xA000_0000. Este endereço reside na não mapeado,
sem cache espaço, a fim de assegurar o reinício.
Na TLB falta exceções e SCALL tem um espaço dedicado em relação
ao EVBA onde seu manipulador de eventos pode ser colocado. Esta
aceleração na execução é conseguida através da remoção da
necessidade de uma instrução de salto colocada no endereço do
programa saltado pelo evento de hardware. Todas as outras exceções
tem um ponto de entrada de rotina de evento dedicado localizado em
relação ao EVBA. O endereço da rotina de tratamento de exceção
identifica a fonte diretamente.
Todos os pedidos de interrupções externas têm pontos de entrada
localizados em uma posição relativa a EVBA. Este deslocamento
autovetorado é especificado por um controlador de interrupção
externa. O programador deve certificar-se que nenhum dos
deslocamentos autovetorado vá interferir na colocação de outro
código. O alcance do deslocamento autovetorado é definido pela
implementação.
As considerações especiais devem ser feitas ao carregar EVBA com um
ponteiro. Devido as considerações de segurança, os manipuladores
de eventos devem estar localizados no espaço de endereço
privilegiado, ou em uma região de proteção de memória
privilegiada. Num sistema com MPU, as rotinas de eventos podem ser
colocadas numa região de proteção cacheável. Em um sistema AVR32B
segmentada, alguns segmentos do espaço de memória virtual podem ser
mais adequados do que outros para a realização de manipuladores de
eventos.
Isto é devido as diferenças de translateability e cacheabilidade
entre os segmentos. A cacheável, não traduzido o segmento podendo
oferecer o melhor desempenho para os manipuladores de eventos, pois
isso irá eliminar quaisquer acidentes na TLB e acelerar a busca de
instrução. O usuário pode também considerar a possibilidade de
bloquear os manipuladores de eventos no cache de instrução.
Se vários eventos ocorrem na mesma instrução, eles são tratados
de forma prioritária. Se os eventos ocorrem em várias instruções
em diferentes locais no pipeline, os eventos sobre a instrução mais
antiga são sempre tratados antes de qualquer evento em qualquer
instrução mais jovem, mesmo que a instrução mais jovem tem
eventos de maior prioridade do que a instrução mais antiga. Uma
instrução B é mais jovem do que uma instrução A se ele foi
enviado para o pipeline até A.
Descrição dos eventos em AVR32A
Exceção de reinício
A exceção de reinício é gerado quando a linha de entrada de
reinício da UCP é afirmado. A exceção de reinício não pode ser
mascarada por nenhum bit. A exceção de reinício repõem todos os
elementos síncronos e registradores no pipeline da UCP para o seu
valor padrão, e inicia a execução da instrução no endereço
0x8000_0000.
SR =
reset_value_of_SREG;
PC =
0x8000_0000;
Todos os outros registradores do sistema são reiniciados para o seu
valor de reposição, que pode ou não ser definido. Para maiores
detalhes veja o capítulo “Programming Model”.
------------------------------------------------------------------------------- 2013/10/10
Nenhum comentário:
Postar um comentário