Memórias
- Memória ROM (Read Only Memory):
Memória cujo conteúdo é construído com semicondutores pré-programados pelo fabricante, muitas vezes de acordo com o pedido do usuário. Apenas de leitura, só pode ser gravada durante seu processo de fabricação e uma vez gravados, os dados contidos em seu interior não podem ser apagados.
Lembrando que para cada endereço existe apenas um dado ou palavra, naturalmente em código binário. Seu conteúdo é não volátil, não se perdendo quando se faz a leitura ou mesmo quando sua fonte de alimentação é desligada. Divide-se em:
. Programmable ROM (PROM ou OPT-ROM): Tipo especial de ROM, que pode ser gravada após seu processo de fabricação. A gravação é realizada através de equipamentos especiais (PROM blower), comumente denominada ‘queima’ da PROM e que pode ser bastante trabalhosa, pelo fato de exigir um circuito especial para o rompimento dos ‘fusíveis’ (diodos), podendo variar inclusive de fabricante para fabricante o método escolhido e uma vez gravados os dados em seu interior, não mais pode ser modificado.
. Erasable Programmable ROM (EPROM): A EPROM é uma memória PROM que pode ter seu conteúdo apagado e regravado novamente. Em sua parte superior existe uma pequena janela de vidro, expondo o circuito que se encontra no interior do chip de memória. Os dados gravados podem ser apagados, através da exposição da janela de vidro (e conseqüentemente o circuito em seu interior) a luz ultravioleta.
. Electrically Erasable Programmable ROM (EEPROM): Este tipo de memória pode Ter seu conteúdo apagado através de aplicação de sinais elétricos pelo sistema. Deste modo, com o seu uso o fabricante do computador disponibiliza a facilidade do usuário atualizar seu equipamento, do ponto de vista de programas básicos. O usuário pode alterar o valor de determinadas células sem a necessidade de apagar a programação em outras células. Assim, seções de dados podem ser apagadas e substituídas sem a necessidade de alterar o resto do chip da programação
- A memória RAM pode ser dividida em estática e dinâmica. Entre as duas há vantagens e desvantagens. A estática (SRAM) é melhor quando se trata de rapidez e ao fato de não necessitar atualização constante; porém quando falamos em preço, consumo de energia e capacidade de armazenamento, a melhor seria a dinâmica (DRAM).
. DRAM: As memórias dinâmicas usam minúsculos capacitores para armazenarem dados em seu interior. Como os capacitores perdem automaticamente a sua carga ao longo do tempo, é necessário fazer de tempos em tempos uma varredura na memória recarregando estes capacitores. Este recarregamento é chamado refresh.
. SRAM: Já as memórias estáticas usam circuitos chamados flip-flops para armazenarem dados em seu interior. Estes circuitos são bem maiores do que os capacitores da memória dinâmica, entretanto estas memórias são mais rápidas, já que não necessitam de refresh.
.PSEUDO STATIC RAM (PSRAM): São memórias pseudo-estáticas que se utilizam das vantagens existentes tanto nas DRAMS quanto nas SRAMS. Possui uma alta densidade de dados e permite trabalhar em modo economico de energia sem perder os dados gravados.
.Non-Volatile Random Access Memory (NVRAM): São memórias não-voláteis de acesso randômico. Utilizada na família de computadores x86 para armazenar os valores da BIOS. Ela mantém controle de diversos parâmetros de sistema, tais como número de série, Ethernet MAC (Media Access Control) endereço, HOSTID, data de fabricação, etc.
- REFERENCIAS:
. MORIMOTO, Carlos. Hardware, Guia de Aprendizagem Rápida, 3ª Edição. Ed. Book Express. Rio de Janeiro, 2004.
. http://www.clubedohardware.com.br/dicionario/termo/272
Multiplicador de P.F.
Só de brincadeira vamos relembrar para os voadores de plantão, Pontos Flutuantes são números quebrados, ex: 1/3 = 0,3333333333333333333333333… e que os processadores possuem um estrutura específica em seu core para trabalhar com esses números que são muito mais difíceis e complicados do que os números inteiros. E para os viciados em jogos, bora lembrar que as partes gráficas utilizam muito o ponto flutuante. Antes de explicar os passos, vamos passar uma figura mostrando uma visão geral do que acontece.
Imagem não muito estranha né?! Será que alguém reconhece? ^^
A primeira coisa a ser feita pelo processador é somar os expoentes de cada número (fazendo uso da ULA pequena, próximo à Unidade de Controle), lembrando de subtrair o bias da soma, para obtermos o valor do novo expoente deslocado.
Feito isso, multiplica-se os significativos (com a ULA grande, a outra né ¬¬’ ) e normaliza o produto quando necessário (Utilizando Incremento). Se esse for o caso, desloca-se o produto para direita (Adivinhe onde ^^’) e o expoente é incrementado.
Se houver um Overflow ou um Underflow, que ocorre quando o resultado obtido é pequeno demais para ser representado em um número de ponto flutuante, será aplicada uma exceção, senão arredonda-se o significando para o número correto de bits (através do Hardware de arredondamento). Caso ainda não esteja normalizado, voltamos para etapa de normalização do produto e permanecemos neste ciclo até que a normalização ocorra.
Finalmente, analisaremos os sinais (através da porta lógica XOR). Se ambos forem iguais, um sinal positivo será atribuído ao resultado, senão, um negativo o será.
Burlando a orientação a objetos do C++ com ponteiros
C++ introduziu alguns conceitos de Orientação a Objetos à linguagem C. Dessa forma podemos trabalhar com encapsulamentos e todas as demais vantagens de uma linguagem Orientada a Objetos. Porém, C++ manteve uma característica importante de C: os ponteiros.
Devido à existência de ponteiros em C++ torna-se possível burlar a Orientação a Objetos suportada na linguagem. Afinal os ponteiros fazem referência direta ao endereço e não à variável.
Segue abaixo um exemplo de código de como isso pode ser feito:
class Burlando {
private: float array [] = {2,3,4,5,6,7};
public:
Burlando();
virtual ~Burlando();
float* ponteiro;
//retorna o endereco da primeira posicao do array
int getAdress(){
return &array[0];
}
//imprime o array
void imprimeArray(){
for (int i = 0; i==6; i++){
cout<<array[i];
}
}
void main(){
Burlando obj = new Burlando();
obj.imprimeArray();
*ponteiro = getAdress();
for (int c = 0; c == 6; c++){
//faz o quadrado do valor do array
ponteiro = ponteiro * ponteiro;
//ponteiro aponta p/ proxima posicao do array
*ponteiro = ponteiro + 2;
}
obj.imprimeArray();
}
};
Neste exemplo, nós criamos um array do tipo float como privado. Criamos como público um ponteiro que aponta para float e um método do tipo int getAdress que retorna o endereço da primeira posição do array privado.
No método main nós instanciamos um objeto da classe, mandamos imprimir os valores do array apenas para comprovar a quebra da Orientação a Objeto. Em seguida atribuímos ao ponteiro o resultado do método getAdress e em seguida modificamos um a um os valores do array, calculando o quadrado deles.
Logo depois, nós mandamos imprimir os valores do array novamente para termos certeza que eles foram modificados. Dessa forma pudemos constatar que a Orientação a Objeto foi burlada.
Um pouco mais sobre compiladores
Breve Histórico dos compiladores
Os primeiros computadores não usavam compiladores, porque eles tinham apenas alguns poucos opcodes (pseudocódigos) e pouca memória e os usuários entravam com código binário de máquina diretamente. No final dos anos 40, os programadores descobriram que o código de máquina tedioso poderia ser representado usando alguns mnemônicos – abreviações de palavras, o que deu origem à linguagem assembly. Adicionalmente, os próprios computadores poderiam traduzir estes mnemônicos em linguagem de máquina.
Durante os anos 50, as linguagens de assembly dependentes da máquina para a qual eram projetadas ainda não eram ideais para os programadores, e por essa razão evoluíram as linguagens de alto-nível e independentes da máquina subjacente. Vários compiladores experimentais foram desenvolvidos desde então, começando com o trabalho de Grace Hopper na linguagem A-0.
O crédito do primeiro compilador completo, em 1957, é atribuído à equipe de desenvolvimento do FORTRAN, liderada por John Backus da IBM. O COBOL foi a primeira linguagem a ser compilada em múltiplas arquiteturas, em 1960.
O primeiro compilador autocontido – ou seja, capaz de compilar o seu próprio código-fonte em uma linguagem de alto-nível – foi criado para o LISP por Hart e Levin no MIT em 1962.
Compiladores vs Interpretadores
Após definir-se a sintaxe e a semântica da linguagem, precisa-se de uma forma eficiente para a implementação de cada um dos elementos da linguagem. Essa implementação é feita por programas processadores: compiladores e interpretadores, ou ainda um misto entre estas formas de processadores.
- Compiladores: os programas são transformados, por inteiro, em um conjunto correspondente de instruções que podem ser fisicamente efetuadas pelo computador. A execução do programa é feita diretamente através dessas instruções de computador; o programa inteiro constitui uma unidade a ser transferida “em um único lote” para o computador.
- Interpretadores: cada expressão do programa é executada diretamente, ou seja, transformada nas instruções correspondentes e acionada no computador sem ter-se a necessidade de transformar o programa inteiro em uma unidade de execução. As expressões do programa são executadas sob demanda.
Um compilador é um programa de computador – ou um conjunto de programas – que traduzem texto(s) escrito(s) em uma determinada linguagem de computador (a linguagem-fonte) em outra linguagem de computador (a linguagem-alvo).
Compiladores
1. Assembly e Compiladores
A razão mais comum para se querer traduzir código fonte é a de criar um programa executável. O nome “compilador” é reservado para programas que traduzem código- fonte de uma linguagem de alto-nível para uma de baixo-nível (por exemplo, em linguagem de máquina ou linguagem assembly).
Linguagem Assembly é uma versão mnemônica do código de máquina, na qual, nomes são usados ao invés de códigos binários. O assembler (montador) converte as instruções em linguagem assembly para a linguagem objeto relocável.
2. Linker
- Tem por função receber o código relocável, produzido pelo assembler, combinar com outros arquivos e gerar um arquivo executável.
- Lembrando que saída do linker é um único arquivo, sendo ainda um código objeto relocável.
3. Loader
O loader possui as funções de:
- Ler o código objeto relocável do disco que foi produzido pelo linker;
- Determinar o endereço de memória que o programa será carregado;
- Alterar os endereços relocáveis das instruções que fazem acesso à memória, obtendo assim o código objeto absoluto;
- Carregar as instruções alteradas e os dados na memória, no endereço apropriado.
Big Endian vs Little Endian
Como proceder para ler dados da memória principal?
Da esquerda para a direita?
Da direita para a esquerda?
Do meio para as extremidades?
Tá, do meio para as extremidades torna-se um tanto desnecessário comentar. No entanto ainda hoje existe a questão: “de que ‘lado’ começar?”
Por um lado temos o Big Endian (ou grande fim O.o) que começa pelo “maior” lado, aquele dos bits MAIS significativos. Do outro temos o Little Endian (precisa dizer que é pequeno fim?) que começa pelo lado “pequeno”, ou seja, o lado que contém os bits MENOS significativos.
O Big Endian tem boas vantagens, afinal ele pensa igual a nós ocidentais. Ele lê da ‘esquerda’ para a direita, do algarismo MAIS significativo até chegar ao MENOS significativo. Isso facilita a nossa vida de programador, uma vez que, utilizando métodos que se assemelhem à nossa natureza, podemos programar com mais facilidade. No entanto grande parte da perda dele se deve justamente ao mesmo fato! Ler os algarismos partindo do mais significativo significa uma grande perda de eficiência ao se incrementar o número, pois para isso deve-se conhecer TODO o número e alocar o espaço necessário para ele. Fora o fato de que, numa busca, primeiro a gente descobre a faixa que ele está, para só então descobrir a linha.
A imagem a seguir, retirada da Wikipédia, demonstra o funcionamento do Big Endian.
O Little Endian tem como desvantagem a vantagem do Big Endian e vice-versa. Afinal ler da direita para a esquerda só dá certo lá no oriente, onde eles lêem até de cima para baixo! Imagine você ter que programar uma coisa que usa um padrão totalmente fora da convenção do dia a dia. Deve ser estranho. Porém, esse modo de leitura facilita na incrementação do número, afinal à medida que se vai lendo os algarismos, vai-se acrescentando-os em seus devidos lugares na ordem MENOS SIGNIFICATIVOS -> MAIS SIGNIFICATIVOS. Isso gera uma certa eficiência, não?
A imagem a seguir, retirada da Wikipédia, demonstra o funcionamento do Little Endian.
Só para salientar, de acordo com esse site (http://support.microsoft.com/kb/102025/pt-br) o Windows NT foi construído com a tecnologia Little Endian e NÃO é compatível com Big Endian. Em sua horrível tradução para o português (tradução automática), o site explica que isso se deve ao fato da maioria dos programas terem dependências com o Little Endian (ao menos foi isso que eu consegui entender O.o).
Acho que por enquanto é só isso =)
Começando…
Não acredito, eu fiz um blog Õ.o
eca ¬¬’
Só a UFS mesmo pra conseguir isso!
Agora as formalidades:
“Banco do conhecimento da dupla Vitor Almeida Costa e Thiago de Mendonça Modesto; referente à disciplina de Arquitetura de Computadores 1 no semestre letivo de 2008/1 da Universidade Federal de Sergipe.”
Depois a gente posta mais alguma coisa…
