Se algum link estiver quebrado
FAVOR avisar: assemblybr@yahoo.com.br
Memória Expandida e EMS
<<--<-- Índice -->-->>
--Config.sys, himem.sys e EMM386.exe--
Até que enfim consegui fazer algo com a memória expandida! Mas antes de mostrar os exemplos é necessário uma boa base teórica, bem como uma configuração correta do config.sys. Sem mais vamos lá!
Um megabyte pode não parecer uma grande quantidade de memória RAM, mas um PC com 1 MB de RAM contém mais de 1 milhão de locais de armazenamento diferentes que podem ser acessados pelo programa. Se vamos tratar da memória, ajudaria muito se nos referíssemos de forma macroscópica a locais precisos dentro do mapa do PC.
Uma forma de entender a memória do PC é observando que, para os segmentos que começam nos limites de 64k, o seu espaço de endereçamento de 1MB pode ser dividido uniformemente em 16 segmentos espaçados por igual; esses endereços de segmento são 0000h, 1000h, 2000h e assim por diante até F000h. Por exemplo, muitos textos registram que o segmento F000h é reservado ao ROM BIOS e os segmentos A000h e B000h, a memória de vídeo.
A figura seguinte mostra um desenho simplificado da forma como a memória é organizada no PC. A área de 640k do segmento 0000h ao A000 é o espaço reservado para a operação do DOS e seus aplicativos. A área de A000h até a parte superior da memória equivale aos 384k reservados para uso do hardware. Especificadamente, os segmentos A000h e B000h são reservados para uso do buffer de vídeo; C000h, D000h e E000h para as controladoras do disco rígido, placas de rede e outros adaptadores, e F000h para a ROM BIOS.
Há um nome para as regiões de memória que vão de 0 a 640k e de 640k a 1MB: Memória Convencional e Memória Superior, respectivamente. Em um 286, 386 ou 486, você não se limita apenas a 1MB de memória; pode instalar memória adicional acima de 1MB, chamada Memória Estendida. E qualquer que seja o tipo de PC, você tem a opção de usar a Memória Estendida, que é acessada de numa forma completamente diferente dos outros tipos de memória.
--Os Quatro Tipos de Memória--
O fato dos processadores da Intel estarem restritos ao endereçamento de 1MB de memória no modo real, e dos fornecedores de software e hardware terem encontrado, com o passar do tempo, métodos para superar essa limitação, significa que nem toda memória é tratada de maneira igual. Há na verdade, quatro tipos diferentes de memória: a Memória Convencional, a Superior, a Expandida e a Estendida. A memória Expandida também é chamada de Memória EMS(Expanded Memory Specifcation).
A figura abaixo mostra o mapa de memória do PC bem como a localização dos quatro tipos de memória.
A área de memória de 0 a 640k(segmento 0000h a A000h) é a Memória Convencional. A área de 640k a 1MB é conhecida como Memória Superior. Na maioria dos casos essa região contém uma combinação de RAM, ROM e espaços de endereçamento não utilizados. Tudo que estiver acima de 1MB é chamada de Memória Estendida. Ele é uma opção apenas para os processadores 286 em diante. A Memória Expandida é exibida ao lado porque não se encaixa nos limites normais do espaço de endereçamento do microprocessador.
Conforme dito, não há muita coisa a se dizer sobre a memória convencional, que se estende de 0 a 640k. Mas há algo a ser dito: Quando um programa executável roda no DOS ele "rouba" ou aloca toda memória convencional que puder. Com isso, se quiser fazer um overlay, terá que alocar apenas a memória que o seu programa irá usar, para que o segundo programa, possa rodar sem problemas. Se desconsiderar isso, o overlay não vai funcionar por falta de memória.
Você já deve saber que um 386 ou 486 pode endereçar até 4G de memória. A memória estendida é aquela que se localiza acima da marca de 1MB. Você não pode ter memória estendida num 8086. Apenas os PCs com microprocessadores do 286 em diante possuem o número de linhas de endereço necessário para formar endereços o suficiente para atingir a memória estendida.
Para que o DOS possa usar a memória estendida, você tem de carregar o driver HIMEM.SYS, que tem como função direcionar o tráfego de memória estendida, usando diretrizes estabelecidas na Extend Memory Specification(XMS) desenvolvida pela AST Research, Intel, Lotus e Microsoft. A XMS fornece um meio independente de dispositivo para que os programas usem a memória estendida sem interferir uns com os outros.
No final de 1984, logo após a introdução do PC AT da IMB, porém bem antes da ampla aceitação do 286, tornou-se óbvio para alguns dos grandes líderes da indústria de computadores que o limite de 640k estava se tornando uma enorme barreira. Os usuários do Lotus 1-2-3 queriam criar planilhas maiores, e a Microsoft estava prestes a lançar a primeira versão do windows, cuja necessidade de memória era a maior exigida por uma aplicação até aquele momento. No final desse ano, a Intel e a Lotus, estavam trabalhando conjuntamente para criar uma especificação que permitisse a todos os PCs acessar mais de 640k de memória RAM.
O Resultado disso aconteceu em 1985, onde se lançou a primeira especificação de memória expandida, a EMS 3.0. Por alguma razão desconhecida, este documento recebeu o número 3.0 para a primeira versão. A Microsoft uniu forças a tempo para ter seu nome afixado na versão 3.2, que foi lançada no final desse mesmo ano e batizada de Lotus/Intel/Microsoft Expanded Memory Specification, ou LIM EMS. A versão 4.0, utilizada atualmente, surgiu em 1987. A EMS foi a única porque foi a base para o acesso a memória independentemente da capacidade de endereçamento do microprocessador.
Algumas das características das três verões da EMS são comparadas na tabela abaixo:
|
Versão da EMS |
Data de lançamento |
Memória suportada |
Funções |
Tamanho da página |
Mapeamento da página |
|
3.0 |
Abril 1985 |
8MB |
14 |
16k |
acima dos 640k |
|
3.2 |
Setembro 1985 |
8MB |
18 |
16k |
acima dos 640k |
|
4.0 |
Outubro de 1987 |
32MB |
58 |
qualquer tamanho |
qualquer lugar |
É importante não confundir memória expandida com memória estendida. Ambas estão normalmente disponíveis na mesma máquina, e, de fato, muitas placas de memória podem ser ajustadas para fornecer memória expandida ou memória estendida, ou ainda uma combinação das duas. Entretanto, a memória estendida só pode ser acessada no modo protegido dos microprocessadores 286 em diante, ao passo que a memória expandida pode ser acessada no modo real, podendo, portanto, ser instalada em máquinas baseadas no 8088/86 do PC original e PC/XT.
O componente por software de um subsistema de memória expandida chama-se Gerenciador de Memória Expandida(EMM - Expanded Memory Maneger). Este programa é instalado ao se inicializar o computador(boot), usando a directiva " DEVICE=" no arquivo config.sys, exatamente da mesma forma que qualquer outro driver de dispositivo. De fato, um EMM possui diversos atributos de um drive de dispositivo de caractere: um cabeçalho de drive de dispositivo; uma rotina que manipula um subconjunto de rotinas que o DOS constrói sobre os drives de dispositivo, e ainda um nome de dispositivo lógico. Este nome de dispositivo é sempre "EMMxxx0", não importando quem tenha fabricado a placa de memória expandida ou escrito o EMM.
Num 386 em diante, o driver EMM386.EXE converte a memória estendida em memória expandida, incorporando o papel de gerenciador de memória expandida e armazenando na memória estendida os dados gravados na memória expandida. Vejamos como se dá esse processo:
O EMM divide toda memória disponível a ele numa série de blocos de 16k chamadas de páginas. Depois, identifica uma área de memória não utilizada de 64k, geralmente entre 640k e 1MB, dividindo-a em quatro páginas (versão 3.0 e 3.2, com a 4.0 você aloca quantas páginas quiser) uniformemente espaçadas de 16k. Esse espaço de 64k é chamado quadro da página.
Para acessar a memória expandida, um programa aplicativo requisita um determinado número de páginas do EMM, que depois as converte individualmente em páginas no quadro da página. A essa "requisição de páginas do EMM" damos o nome de páginas lógicas. A "conversão de páginas" damos o nome de páginas físicas. Dessa forma um programa poderá ler/gravar nessa página lógica usando endereços de segmento:deslocamento padrão. Quando o programa quer acessar outras páginas lógicas, ele chama o EMM outra vez para ligar novas páginas lógicas as páginas físicas no quadro de página. Ao repetir o procedimento várias vezes , o programa poderá acessar toda memória expendida que ele alocou em incrementos de 16k, usando o quadro de página como uma janela para a memória expandida.
Entretanto, os aspectos do driver de dispositivo de um EMM são apenas aparentes. As principais funções do EMM são: controlar o hardware de memória expandida, administrar a memória expandida como um recurso do sistema que pode ser usado por vários programas diferentes ao mesmo tempo e servir as funções definidas na EMS. Os programas utilizam estas funções por intermédio do EMM diretamente, usando uma interrupção por software que o MS-DOS considera "reservada"; o MS-DOS não participa do gerenciamento da memória expandida.
A tabela abaixo lista um subconjunto de funções da EMS. Em breve colocarei o conjunto completo das funções. Mas para os propósitos de um programa aplicativo típico, é mais que suficiente. O uso de tais funções é muito simples. Por exemplo: o número da função da EMS é sempre colocado no registro AH, o número das páginas lógicas no registro BX, os manipuladores de memória expandida no registro DX e assim por diante. O controle é transferido de um programa para o EMM executando a int 67h. Todas as funções da EMS indicam sucesso retornando com zero no registro AH, ou uma falha retornando com código de erro em AH, com bit mais significativo igual a 1.
|
Função da Memória Expandida |
Chamada com |
Retorna |
|
Obtém o status |
AH = 40h |
AH = status |
|
Obtém o endereço da página de molduras |
AH = 41h |
AH = stataus BX = segmento da página de molduras |
|
Obtém número de páginas da memória expandida |
AH = 42h |
AH = status BX = páginas disponíneis DX = Número total de páginas |
|
Aloca páginas |
AH = 43h BX = número de páginas |
AH = status DX manipulador do EMM |
|
Mapeia a página da memória expandida |
AH = 44h AL = página física BX = página lógica DX = Manipulador do EMM |
AH = status |
|
Libera páginas |
AH = 45h DX = manipulador do EMM |
AH = status |
|
Obtém a versão do EMM |
AH = 46h |
AH = status AL = versão |
Em resumo, para o formato geral de uma chamada em linguagem assembly a uma função do EMM é:
mov ah,funcao ;AH = número da função do EMM
. ;Carregar os demais registros com os valores
. ;especificos a função
.
int 67h ;transfere o controle para o EMM
or ah,ah ;testa o status da função da EMS
jnz erro ;desvia se encontrar erro
-Obtendo Acesso a Memória Expandida-
Existem dois meios para testar se a memória expandida está instalada em seu sistema. O método da "abertura de arquivo" e o do "vetor de interrupção". Bem, não estou com saco de descrever nenhum deles, então passe logo para o tópico " Config.sys, himem.sys e EMM386.exe " para que saiba instalar e configurar o EMM.
-Usando a Memória Expandida-
Para ter acesso a memória expandida temos que seguir alguns passos básicos. O primeiro é determinar qual a versão do EMM está disponível, para se certificar de que estão presentes todas as funções do EMS que você pretende usar. Logo em seguida deverá chamar a função "obtém o número de páginas"(função 42h da INT 67h) para determinar a quantidade de memória expandida disponível. Esta função retorna tanto com o número de páginas lógicas instaladas como o número de páginas que ainda não foram alocadas por outros programas. Na maioria dos casos esses dois números serão iguais, a menos que seu programa esteja sendo executado em conjunto com outros num ambiente multitarefa que use a memória expandida, ou a menos que tenha sido carregados previamente TRSs ou drives de dispositivo que utilizem a memória expandida.
Se o número de páginas livres da memória expandida for menor do que aquele que seu programa necessita ou espera encontrar, este deverá decidir se continua com a execução numa versão "mais simples" ou emite uma mensagem de aviso e termina. Entretanto, se existirem páginas disponíveis em número suficiente, o programa poderá prosseguir e chamar a função "aloca páginas da EMS" (função 43h da INT 67h) para alocar a quantidade de memória expandida necessária. A função para alocação do EMM retorna com um "manipulador do EMM" - um valor de 16 bits que simboliza as páginas de memória expandida do programa e que deve ser utilizado em todas as referências subseqüentes a essas páginas. Esse manipulador é absolutamente análogo aos manipuladores de arquivo e de dispositivos aos quais você já está acostumado desde as suas experiências anteriores de programação em MS-DOS.
O último passo para obtenção de recursos da memória expandida é chamar a função "obtém o endereço da moldura de páginas" ( função 41h da INT 67h) da EMS. Esta função retorna com o segmento, ou parágrafo, da base da moldura de páginas do EMM, a área usada pelo EMM para mapear as páginas lógicas da EMS na memória convencional. O endereço da moldura de páginas nunca se altera após o sistema ter sido inicializado. Sendo assim, você só precisa requisitar este endereço uma vez durante o código de inicialização do seu programa. Uma seqüência típica do teste do status EMM, alocação de algumas páginas da EMS e extração do endereço da moldura de páginas está ilustrado a seguir:
pag dw 4 ;requisita 4 paginas
moldura dw ?
total_pag dw ?
pag_disponiveis dw ?
handle_pag dw ?
.
.
.
mov ah,40h ;obter o status do sistema da EMS
int 67h
or ah,ah
jnz erro ;desvia no caso de erro
mov ah,46h ;verificar a versao do EMM
int 67h
or ah,ah
jnz erro
cmp al,32h ;verifica se EMS e maior que 3.2
jb erro ;desvia se for menor
mov ah,42h
int 67h
or ah,ah
jnz erro
mov total_pag,dx ;salva numero total de paginas
mov pag_disponiveis,bx ;salva numero de pag disponiveis
mov bx,pag ;paginas suficientes ?
jb erro ;desvia se for menor
mov ah,43h ;aloca paginas da EMS
mov bx,pag ;numero de paginas necessarias
int 67h
or ah,ah
jnz erro ;desvia se paginas nao estiverem alocadas
mov handle_pag,dx ;salva o manipulador
mov ah,41h ;obtem a moldura da EMS
int 67h
or ah,ah
jnz erro ;desvia no caso de erro
mov moldura,bx ;salva segmento da moldura
As páginas lógicas da EMS pertencentes a um programa e associadas a um determinado manipulador da EMS estão numeradas de 0 a N - 1, onde N é o número total de páginas originalmente alocadas por esse manipulador. Nas EMS 3.0 e 3.2, as páginas possume sempre 16k de comprimento. A EMS 4.0 permite a alocação de páginas de outros tamanhos, mas é melhor evitar o uso de tamanhos não padrão de páginas para que o seu programa seja compatível com a maior faixa possível de hardware e software para EMS.
Nas EMS 3.0 e 3.2 está sempre disponível uma página mapeada na moldura de páginas do EMM, que por sua vez está localizada em endereços não usados acima da fronteira dos 640k. A moldura de páginas possui 64k de comprimento e está dividida em quatro páginas físicas de 16k numeradas de 0 a 3.
A EMS 4.0 oferece suporte a uma moldura de páginas no estilo EMS 3.x por razões de compatibilidade, embora a moldura de páginas possa ser maior que 64k e também possam existir várias molduras de páginas. E EMS 4.0 também permite que páginas sejam mapeadas abaixo da fronteira de 640k, se estiver presente o hardware apropriado. Novamente é melhor evitar o uso dessas capacidades que são peculizares a EMS 4.0, a menos que que programa não possa ser elaborado sem tais recursos.
Uma vez que uma página lógica tenha sido mapeada em página física, poderá ser inspecionada e alterada por meio de instruções normais da CPU de acesso a memória. Ao lidar coma moldura e o tamanho de páginas do padrão EMS 3.x, os cálculos dos endereços são bastante diretos.
Aqui cabe uma pausa para esclarecer os seguintes itens:
1- "O que é página lógica?"
2- "O que é quadro de página?"
3- "O que é página física?"
4- "O que significa 'mapear uma página lógica numa física'?"
1- A página lógica é uma área de memória, cuja localização é indefinida, que NÃO pode ser alcançada diretamente no modo real, pois está acima dos 1M bytes de memória convencional.
2- Como não é possivel ler/escrever acima dos 1M bytes da memória convencional, se faz necessário o uso de um meio indireto para que se possa transferir o conteúdo que está acima dos 1Mbytes(página lógica) para alguma região ABAIXO dos
1Mbytes. Este local(nas versões 3.x) deve ter 64k de espaço livre, pois servirá de buffer para as operações de leitura/escrita na EMS. Portanto, quadro de página é um espaço de 64k bytes, em alguma região da memória convencional, que serve de buffer para operações de escrita/leitura na EMS. É por meio deste 'quadro' que os programas que rodam no modo real, podem efetuar operações de escrita/leitura acima dos 1Mbytes.
3- Chama-se página física a divisão por 4 do quadro de página. Na verdade o verdadeiro buffer é uma página física de 16k bytes(nas versões 3.x). Deste modo, as operações de escrita/leitura na EMS são feitas de 16 em 16k bytes, por causa do tamanho do nosso buffer.
4- 'Mapear' significa tornar visível 16k bytes da EMS no nosso buffer, a página física. Como o quadro de página é um endereço real, a página física também o é. Logo, o que estiver nela poderá ser lido/escrito a vontade!
Obs: 16k bytes = 4000h
O uso de páginas lógicas e físicas, visa facilitar a escrita/leitura de determinadas faixas de endereço da memória expandida. Por isso é útil pensar na memória expandida pertencente a um programa como um arquivo virtual(vetor) com o comprimento igual a N * 4000h (onde N é o número de páginas alocadas da EMS). O uso das páginas lógicas e físicas para a escrita de certas faixas da EMS é mostrada nos exemplos que estão no fim desta página.
Veja como mapear uma página lógica numa página física e escrever alguns dados nela:
pag dw 12 ;paginas da EMS requisitadas
moldura dw ?
pag_logica dw 0
pag_fisica dw 2
hanlde_pag dw ?
frase1 db "O AssemblyBR ta Irado","$" ;21 bytes
.
.
.
mov ax,44h ;mapeia a pagina da EMS
mov bx,pag_logica ;pagina logica 0
mov al,byte ptr pag_fisica ;pagina fisica 2
mov dx,handle_pag ;manipulador da EMS
int 67h
or ah,ah
jnz erro
;constroi o ponteiro FAR para a pagina
mov es,moldura ;ES=segmento da moldura de paginas
xor dx,dx
mov ax,4000h ;4000h = 16k
mul pag_fisica
mov di,ax ;contem o offset do quandro de pagina
;agora podera usar DI para escrever/ler o quiser
;na memoria expandida.
lea si,frase1
escreva_ems:
cmp [si],byte ptr "$"
je fim
mov al,[si]
mov es:[di],al
inc si
inc di
jmp escreva_ems
;ou entao:
;
;lea si,frase1
;mov cx,21
;
;escreva_ems:
;
;lodsb
;stosb
;
;loop escreva_ems
;
Isso só acontecerá se você tiver antes visto a versão da EMS, verificado se há páginas suficientes e mapeado a página lógica em página física.
Será que você realmente entendeu como funciona a memória expandida ? A lógica é esta:
1- De quanta memória eu vou precisar ? Digamos que seja 700k
2- Qual o tamanho de cada página ? Digamos que seja 16k ou 4000h
3- Quantas páginas são necessárias para alocar 700k? Resp: 44 páginas, pois
700/16 = 43.75 = 44
4- Mapeamos a página lógica 0 em uma página física de sua escolha. Mas nesse exemplo, escolho página física 2
5- Escrevemos/lemos dados na faixa de 0 a 3FFFh(pois o tamanho da página
escolhida foi de 4000h = 16k). Assim que for escrito/lido o dado de posição 3FFFh,
incrementa-se o valor da página lógica e a mapeamos novamente na página física 2. Em seguida escrevemos/lemos dados na faixa de 0 a 3FFFh.
6- Se o processo do item 5 for repetido 44 vezes, iremos alocar 704k, cobrindo os 700k que foram requisitados.
Portanto, que fique bem claro o seguinte: para escrever/ler na memória expandida você deve mapear uma página lógica em uma página física. Se o tamanho de apenas uma página lógica não for suficiente para sua aplicação, você escolhe outra página lógica e a mapeia numa página física. Dessa forma você consegue endereçar mais de 1M com muita facilidade.
Fixe a idéia de que a EMS é um simples vetor, començando da página lógica 0 e indo até, por exemplo, a página lógica 64. Desse modo se você mapear uma a página lógica 2 na física 1 ou a página lógica 2 na física 3, estará apontando sempre para o mesmo local, pois a página física, conforme visto, é apenas um buffer para a EMS servindo portanto para a armazenamento temporário de dados.
Bem, até aqui eu "falei, falei" e exemplo que é bom nada! Sendo assim, para usar as rotinas do AsmBR, baixe estes arquivos e os inclua no seu código seguindo este esqueleto:
.386
.387
OPTION SEGMENT: USE16
;------------------------------------------------------
includelib videoBR.lib
includelib binBR.lib
;------------------------------------------------------
SEU_SEG_PILHA SEGMENT STACK
DB 1024 DUP(?)
SEU_SEG_PILHA ENDS
SEU_SEG_DADOS SEGMENT
.
.
.
SEU_SEG_DADOS ENDS
AsmBR SEGMENT PARA PUBLIC 'AsmBR2'
ASSUME CS:ASMBR, DS:SEU_SEG_DADOS,
ES:SEU_SEG_DADOS, SS:SEU_SEG_PILHA
;------------------------------------------------------
include videoBR.br
include binBR.br
;------------------------------------------------------
SEU_INICIO PROC FAR
MOV AX, SEU_SEG_CODIGO
MOV DS, AX
MOV ES, AX ;requerido, pois a INT 10h serviço 13h
;usa ES:BP como ponteiro para o caractere a ser impresso. A não ser
;que especifique em qual segmento estará a variável que será usada
;por ES:BP
.
.
.
MOV AX,4C00H ;sair do DOS
INT 21H
SEU_INICIO ENDP
SEU_SEG_CODIGO ENDS
END SEU_INICIO
Para maiores detalhes veja o fonte dos arquivos EMS1.ASM, EMS2.ASM, EMS3.ASM e
EMS4.ASM
Sinto muito mas acabou a minha paciência, e tudo que tenho pra dizer sobre a memória superior é: Carregue tudo que puder lá, para que sobre um pouco mais de memória convencional.
--Config.sys, himem.sys e EMM386.exe--
Este tutorial sobre memória expandida me encheu o saco, por isso o "por que" dessa configuração deixarei para a próxima atualização.
devicehigh /s=C:\WINDOWS\himem.sys /INT15=4096
devicehigh /s=C:\WINDOWS\emm386.exe ram 4096 h=128 MIN=2048
dos=high,umb,auto
buffershigh=99,8 /x
stackshigh=64,512
FILESHIGH=128
OBS: Estas configurações só têm validade no modo real. Já sob o sistema windows, tem prioridade as configurações da janela do prompt do DOS. Para ter acesso a elas, clique no botão propriedade e escolha a guia 'memória'.
E conforme a figura, escolha quanta memória o sistema o irá disbonibilizar a EMS. Quanto resto, deixe como está.
Pode baixar o emm386.exe se não o tiver.
Assim que o programa for executado irá aparecer o seguinte:
Aqui você escolhe o número de páginas que deseja alocar. Lembrando que o número de páginas disponíveis é de 64, não poderá escolher um número de 'páginas alocas' superior as disponíveis. Este programa faz uso das rotinas do ASMBR2, por isso caso digite um número errado, pode usar o bacspace para apagá-lo. Mas digamos que tenha escolhido 10 páginas e teclado enter, para confirmar. Após isso surge:
Neste ponto você deve escolher o número da página lógica e em seguida confirmar com enter. Caso tenha digitado um número indesejado, tecle backspace para apagá-lo. Agora deverá escolher a página física. Nesse exemplo, vou escolher a página lógica 0 e a página física 2. Depois disso temos:
Agora estaremos fazendo uso das rotinas do ASMBR, e portanto poderá escrever o que quiser, bem como usar o backspace, esc, delete, setas, home e end. Não poderá passar de 80 caracteres na linha. Caso contrário, o cursor ficará na coluna 79, não importando o que digite depois. Se quiser apagar a toda linha, tecle ESC. Para salvar o que escreveu na memória expandida, tecle enter. Nesse exemplo eu vou escrever:
"O AssemblyBR ta IRADO!!!" e confirmar com enter. O seguinte aviso é exibido:
Nenhum outro caractere que não seja "S" ou "s" e "N" e "n" é aceito nesta parte. mas para ilustrar como alocar mais memória, vou escolher "S". Há, não é necessário confirmar com enter, basta teclar "S" ou "s" e "N" ou "n". Nesse instante, o programa pede para mapear outra página lógica e física.
Novamente o programa pede para escrever na memória expandida. Escolhi a ''página lógica' 2 (que está na faixa de 0 a 9, visto que aloquei apenas 10 páginas) e a física 1. Você poderia alocar outra página física na faixa de 0 a 3, somente, pois o quadro de página só possue 64k e nele há 4 páginas físicas(de 0 a 3) de 16k. Vou escrever "AssemblyBR, O melhor site de programacao assembly do Brasil!!!"
Tecle em "N" ou "n" se quiser ver o escreveu no debug. Para tanto faça:
"XM" irá mapear a página lógica em uma página física. O primeiro número depois de "xm" representa a página lógica, o segundo a página física, e o terceiro é o manipulador ou handle. Afirmo ser 1 pelo fato de estar executando o ems1.exe pela primeira vez. Mas caso o tenha executado mais de uma vez, observe qual o número do handle retornado ao executar o ems1.exe. Após teclar enter a frase( "A página...) acima é exibida.
Feito isso, aponte para o quadro da EMS na memória convencional. Observe lá nas figuras acima que ao se escolher página lógica 0 e página física 2, foi retornado o endereço real D000:8000h que conterá os dados escritos da EMS. Mas como foi possível chegar a esse número? Lembre mais uma vez que a moldura da EMS é um segmento de memória NÃO utilizado pelo sistema, e por isso, passou a ser reservado pelo a drive EMM386.EXE. É neste segmento(no meu PC é D000h) que poderemos ler/escrever na EMS. Mas em qual offset? É o valor da página física multiplicado por 16k(4000h) que irá corresponder ao nosso offset. Portanto multiplicando o valor 2 da página física por 4000h obtemos 8000h.
O comando "d" do debug (de "display") exibe o conteúdo dos endereços de D000:8000 até D000:8070
"E como ver os dados gravados na pagina lógica 2 e mapedo na página física 1 ?"
Conforme visto acima basta mapear a 'página lógica' 2 na 'página física' 1 e em seguida apontar para o quadro da página na memória convencional, que é D000:4000h, usando o comando "d" do debug.
"E caso eu quiera escrever na EMS usando o debug ?" Basta usar o comando "f" (F significa preencher - inglês "fill", que preenche a faixa de dados especificada com os dados que você determinar. Para tanto, você deve primeiro mapear uma página lógica numa física. Depois de ter feito isso faça:
F D000:4000 50 "Mande sue fontes para o AssemblyBR ja! "
Essa frase será escrita repetidamente para 50h bytes de RAM de D000:4000 a D000:4050. Para ver o que escreveu faça:
D D000:4000 50
Pronto! Está feito. Só resta deslocar as páginas associadas ao handle 1(ou ao que você estiver usando) digite:
XD 1
O debug irá dizer: "Identificador 0001 deslocado" Você deve ficar atento ao seguinte: Se executar o ems1.exe, mais de uma vez, o número de handles de EMS alocados será igual ao número de vezes que você executou o ems1.exe. Portanto, para deslocar estes handles você deve executar o comando "XD" do debug especificando o número do handle que deseja deslocar ou usar o programa ems4.exe, que será o último a ser explicado.
E finalmente o ems1.zip.
O ems2.exe irá salvar o conteúdo de um arquivo na EMS. Por isso é solicitado um nome de arquivo. Vou abrir o arquivo 'ddd.jkl'.
Como sabe, cada página lógica padrão tem 16k. Logo 51200 bytes dividido por 16k resulta em 4. Por isso iremos alocar 4 páginas. Em sequida você pode escolher a página física. Pode ser qualquer uma na faixa de 0 a 3.
Baixar o ems2.exe.
Caso deseje ver o conteúdo do arquivo no Debug, basta entrar com o endereço real D000:4000h. Mas poderá, com o ems3.exe, salvar as páginas lógicas(começando sempre da zero) da EMS em um arquivo qualquer.
Vimos como salvar um arquivo qualquer na EMS usando o ems2.exe. Agora veremos como salvar um ".COM" na EMS bem como executá-lo. Crie um arquivo chamado ems_com.asm. O seu código será:
codigo segment
assume cs:codigo, ds:codigo, es:codigo, ss:codigo
;
;OBS: o ORG 100h que caracteriza um '.COM' so faz sentido para o sistema
;operacional na hora em que o programa eh carregado na memoria.
;Este ".COM" NAO sera carregado pelo MS-DOS. Por isso nao eh necessario o ORG
;
inicio proc far
push cs
pop ds
mov ax,3
int 10h
mov ah,9
lea dx,frase1 ;imprime DS:DX
int 21h
xor ax,ax
int 16h
retf ;retorna ao IN_EMS1.EXE
;pois na pilha ainda ha o CS e o IP do programa
;IN_EMS1.EXE, salvos com o 'CALL SALVA_CS_IP'
frase1 db 13,10,"Aqui no AssemblyBR funciona mesmo!",13,10
db "Ainda estou no '.COM', tecle alguma coisa para sair...",13,10,"$"
inicio endp
codigo ends
end inicio
Agora compile dessa forma: ml /AT ems_com.asm
"AT" deve ser maiúsculo. Depois rode o ems2.exe e entre com o nome: ems_com.com. Pronto! Só resta rodar o in_ems1.exe, entrando com a página lógica inicial e o número do handle e depois confirmar mais uma vez: "No AssemblyBR Funciona mesmo!"
Baixar o ems3.exe
O ems3.exe irá salvar o conteúdo da EMS começando sempre da página lógica 0. Digamos que tenha executado o ems2.exe e salvo algum arquivo na EMS. O ems3.exe irá recuperar este arquivo. Do exemplo anterior, sabemos que o arquivo 'ddd.jkl' ocupa 4 páginas lógicas e usa o handle 1. Quanto a página física você pode escolher qualquer uma, tanto no ems2.exe quanto no ems3.exe que o resultado será o mesmo.
Ao rodar o ems3.exe basta então escolher um nome de arquivo, entrar com o número de páginas lógicas a serem lidas, o número do handle usado e, opcionalmente, o número da página física. Feito isso, basta o abrir o arquivo e confirmar mais uma vez:
"No AssemblyBR Funciona mesmo!"
O ems4.exe tem a função de liberar os handles da EMS. Mas antes é mostrado na tela o número do handle bem como quantas páginas foram alocadas. O handle 0 é do sistema e não pode ser liberado. Nesse exemplo vou escolher teclar "s"(só são aceitas as teclas "S","s","N" ou "n").
Baixar o ems4.exe.
Escolhendo o handle 1 iremos liberá-lo. Poderá rodar o ems4.exe novamente e verificar que o handle 1 foi liberado. E novamente: "No AssemblyBR Funciona mesmo!"
Bem... dúvidas, criticas e sugestões direto
para o fórum