Moja dziewczyna ma świetną pamięć

Do niedawna dziewczyna czesto zapominala cos co miala zrobic, raz zapomniala ze sie ustawila ze mna na randke. Wynikalo to,ze ma tylko 1 megabajt pamieci. Wiecej nie obslugiwal sterownik.Postanowilem napisac sterownik pamieci EMS (rozszerzonej),zeby więcej pamietala :) I tak tym sposobem moja panna pamieta wiecej niz 1 MB Poniżej opis będzie

Dawno temu pojawiło się zapotrzebowanie na komputery z RAMem mieszczącym więcej niż 1MB. Wtedy to jakiś geniusz wymyślił, że dostęp do niej będzie się odbywać poprzez tryb chroniony. Jest to w sumie fajna sprawa, ale niestety komplikuje wiele prostych w trybie rzeczywistym rzeczy (m.in. brak przerwań). Tryb rzeczywisty, czyli to czym dysponujemy w Turbo Pascalu (Uwaga: w Borland Pascalu można kompilować programy do trybu rzeczywistego, chronionego i pod Windowsa!), został brutalnie zamordowany. Bo na co komu coś takiego, co nie może obsłużyć pamięci ponad 1MB w czasach, kiedy komputery mają jej tysiące razy więcej? Ale my reanimujemy tryb rzeczywisty. Po pierwsze: bez żadnych tricków możesz dossać się do pierwszych 64 kB ponad 1MB - tzw HMA; jest to po prostu adres $FFFF:$0010 i wyżej; jak widzisz $FFFF0+$10 daje $100000, czyli adres pierwszego megabajta (swoją drogą powinien być to miły, nie sygnalizowany błąd przekroczenia zakresu dodawania w procesorze 386 - tak jest na 286, ale kto tam pamięta te starocie). Jeśli program emm386 nie został uruchomiony z opcją RAM, to HMA jest wolny i możesz po nim pisać ile wlezie. Zawsze to o 64kB (minus 16 bajtów) więcej. Jednak istnieje coś dużo lepszego: dorwiemy się do pewnej furtki "przypadkiem" pozostawionej przez Intela i namiętnie wykorzystywanej przez różnego rodzaju menedżery pamięci rozszerzonej (chodzi o to, że można uruchomić niejako w tle program w trybie chronionym, wrócić do trybu rzeczywistego, a za pośrednictwem przerwań komunikować się z tym programem z trybu chronionego). Za pośrednictwem sterownika emm386 (standardowo ładowanego na kompach z Windozą 9x/Me), który udostępnia nam coś, co się nazywa EMS, wgryziemy się w tyle pamięci, ile jest na komputerze, a przy odrobinie szczęścia zrobimy obiekt piszący po EMS jak po pliku, oraz coś w rodzaju menedżera pamięci trybu chronionego - tzn. będziemy korzystać nie tylko z EMSu, ale i dysku. Nie będę wnikać w teorię dotyczącą działania pamięci rozszerzonej (EMS), jeśli ktoś jest chętny to mój adres mejlowy jest na dole artykułu. Zaczniemy od poznania działania przerwania 67h, bo to ono nam posłuży do komunikacji z EMM. Co potrzebujemy? Najpierw sprawdzamy, czy aby emm386 jest uruchomiony, posługując się odpowiednią funkcją DOSu (int 21h). function DetectEMS : boolean; assembler; const EMM : array of char = 'EMMXXXX0'; asm mov ax,3567h int 21h mov di,0Ah lea si,EMM mov cx,8 repz cmpsb jnz @@1 mov ax,1 jmp @@2 @@1: mov ax,0 @@2: end; Jeśli ta funkcja zwróci wartość true, to pędzimy dalej: sprawdzamy, czy aby jest trochę wolnej pamięci EMS: function GetEMSFreePages : word; assembler; asm mov ah,42h int 67h mov AX,BX end; Funkcja zwróci ilość wolnych stron ("ramek"). Jedna ramka to 16kB pamięci, więc GetEMSFreePages*16*1024 zwróci ilość wolnej pamięci EMS. Przy okazji możemy sprawdzić, ile pamięci EMS jest w ogóle: function GetEMSAllPages : word; assembler; asm mov ah,42h int 67h mov AX,DX end;

dokładnie kolego

Tak, masz rację autorze :P

Dawno nie czytałam asemblera :D Mniam, mniam :)

Pierdolnij sie w czerep zakompleksiony pryszczaty onanisto.

czynienia z assemblerem . Ale kontynuuj - b.ciekawe . Acha i ja tez jestem DOS- sowski :D

:P

zamiast sie tu stressowac w nieznanym ci temacie lepiej poczytaj na temat analu i stressu jaki cie w zwiazku z tym czeka ...

chyba zaloze podpaskie bo czuje sie wilgotny i podniecony tym analem :D

hapam rodzyny z biedronki ale nie mow tego nikomu prosze cie ... :P

:P:P:P:P:P:P:P:P:P:P:P

Skoro już wiemy, że EMM jest zainstalowany, i że mamy mnóstwo wolnej pamięci (tzn. więcej niż zero stron), to już jesteśmy gotowi do upychania danych w pamięć ponad pierwszym megabajtem. jeszcze tylko mała uwaga: środowisko tpx.exe bez zastanowienia połyka nam całą pamięć EMS, i dla nas nie zostaje nic. Co na to poradzić? Albo posługiwać się kompilatorem tpc.exe czy turbo.exe (co jest bardzo niewygodne), albo bawić się pod Windozą (uruchamiamy tpx w oknie DOSowym i jest tak jak wcześniej: tpx zabiera całą pamięć, ale... ale Windows doczarowuje drugie tyle na potrzeby naszego programu :)). Możemy też w autoexecu ustawić wartość odpowiedniej zmiennej poleceniem set: niestety nie pamiętam nazwy tej zmiennej (czy ktoś mógłby?...). Teraz małe słowo o organizacji pamięci EMS: w wyniku alokacji pamięci dostajemy nie wskaźnik ale uchwyt do naszego bloku pamięci. mając go korzystamy z kilku funkcji, które wrzucą nasze dane do pamięci EMS bądź je stamtąd pobiorą. Alokować możemy dowolnie dużą ilość pamięci, jednak dane możemy kopiować i pobierać tylko i wyłącznie w maksymalnie szesnastokilobajtowych porcjach. I koniecznie trzeba pamiętać o zwalnianiu pamięci, kiedy już nie jest potrzebna, bo może się po prostu skończyć. To popatrzmy na funkcje do obsługi pamięci EMS: function GetEMSmem(pages : word) : word; assembler; asm mov ax,4300h mov bx,pages int 67h cmp ah,0 jne @@1 mov ax,dx jmp @@2 @@1: xor ax,ax @@2: end; Alokuje blok pamięci EMS, a następnie zwraca uchwyt do niej i coś w rodzaju wskaźnika, (przeważnie równego wartości ptr($0E0000)), co umożliwi nie do końca prawidłowe korzystanie z naszej pamięci :). Jeśli uchwyt (tzn. wartość zwracana przez funkcję) jest równy zeru, to znaczy że coś jest nie w porządku. function FreeEMSmem(handle : word) : word; assembler; asm mov ax,4500h mov dx,handle int 67h end;

Ta procedura zwolni blok pamięci EMS o podanym uchwycie (spróbujcie "na sztywno" uruchomić FreeEMSmem(0) i FreeEMSmem(1) - oczywiście po backupie całego dysku... - podane uchwyty to pamięć bufora dysku - smartdrv). Teraz pierwsza metoda na przyssanie się do danych - bezpośrednio z pamięci DOS: wywołujemy procedurkę procedure ResEMSmem(handle : word); assembler; asm mov ah,48h mov dx,handle int 67h end; która wpisze pierwsza (i tylko pierwszą) ramkę naszej pamięci do okna znajdującego się pod adresem, który obczaimy sobie następną funkcją: function GetEMSSegment : word; assembler; asm mov AH,41h int 67h mov ax,bx end; Wtedy modlimy się, żeby żaden inny program w tym czasie nie korzystał z pamięci EMS, i bezczelnie traktujemy pierwsze 16kB pod adresem GetEMSSegment:0 jako naszą pamięć: co tam zmienimy, to zostanie zmienione również w pamięci EMS. Ale jeśli jakiś inny program w międzyczasie też korzystał z pamięci EMS, to mamy problem, bo nie zmienimy naszych danych, tylko tego programu. Czyli nieźle napsujemy, bo tym "innym" programem jest najczęściej bufor dysku :) Dlatego polecam poniższą metodę. function MoveToEMS(var buf;handle,page,offs : word;size : word) : byte; assembler; var emms : TEMMRec; asm xor ax,ax cmp size,0 je @@1 cmp handle,0 je @@1 mov ax,size mov emms.size.word,ax mov emms.size.word,0 mov emms._from,0 mov emms.srchandle,0 les di,buf mov emms.source.word,es mov emms.source.word,di mov emms._to,1 mov ax,handle mov emms.dsthandle,ax mov ax,offs mov emms.dest.word,ax mov ax,page mov emms.dest.word,ax push ds lea si,emms mov ax,ss mov ds,ax mov ax,5700h int 67h pop ds mov al,ah @@1: end; function MoveFromEMS(handle,page,offs : word;var buf;size : word) : byte; assembler; var emms : TEMMRec; asm xor ax,ax cmp size,0 je @@1 cmp handle,0 je @@1 mov ax,size mov emms.size.word,ax mov emms.size.word,0 mov emms._from,1 mov ax,handle mov emms.srchandle,ax mov ax,offs mov emms.source.word,ax mov ax,page mov emms.source.word,ax { logical page } mov emms._to,0 mov emms.dsthandle,0 les di,buf mov emms.dest.word,es mov emms.dest.word,di push ds lea si,emms mov ax,ss mov ds,ax mov ax,5700h int 67h pop ds mov al,ah @@1: end; MoveToEMS(var p; h,offs,count : word) - z pamięci konwencjonalnej (DOS) kopiujemy dane do pamięci EMS. p to bufor z danymi, h - uchwyt bloku EMS, offs - jeśli nie chcemy upychać danych od zerowego bajta (coś jak seek, np.: jeśli chcemy upchnąć do pamięci EMS dwie kopie bufora, robimy tak: MoveFromEMS(bufor,f,0,SizeOf(bufor)); MoveCE(bufor,f,SizeOf(bufor),SizeOf(bufor)) i już). count - liczba bajtów do skopiowania. Analogicznie działa MoveEC(h,offs : word;var p;count : word) - z pamięci EMS do pamięci DOS. h - uchwyt bloku EMS, offs - przesunięcie względem początka danych, p - bufor, cound - ile bajtów skopiować. Proste?

A czy twojej dziewczynie wygywaja sie gry z C64?

no rewelacja, ale na pewno wiesz o czym piszesz? :O

Tak wiem o czym piszę:) Np gra Polanie wykorzystywała pamięć EMS

nie myslcie oczywiscie ze jestem jakims nieczulym na wszystko sztywniakiem to ze jestem informatykiem nie oznacza ze nie lubie sie zabawic z moja dziewczyna np: lubimy lizac sobie nawzajem tyleczki i tak dalej ale nie ukrywam ze informatyka jest jednak GLOWNA moja pasja :-)

Dalsza część Przydać się może jeszcze jedna procedurka - analogiczna do truncate: function ReallocateEmsPages(handle,newsize : word) : byte; assembler; asm mov AH,51h mov DX,handle mov BX,newsize int 67h mov al,ah end; I to właściwie wszystko, co jest potrzebne do efektywnego korzystania z pamięci EMS. Można skorzystać z jeszcze jednej, rzadko używanej funkcji do nazwania badź odczytania nazwy przypisanej do uchwytu (tak! można nazywać nasz blok pamięci; konwencja nazewnicza jak w plikach, ale bez rozszerzenia). type string8 = string; function GetEMSHandleName(h : word) : string8; var s : string8; begin asm mov byte ptr s,8 lea di,s mov ax,ss mov es,ax mov ax,5300h mov dx, int 67h cmp ax,0 jz @@1 mov byte ptr s,0 @@1: end; if pos(#0,s) > 0 then s := char(pos(#0,s)-1); GetEMSHandleName := s; end; procedure SetEMSHandleName(h : word;name : string8); assembler; asm push ds push si lea si,name mov ax,ss mov ds,ax mov ax,5301h mov dx, int 67h pop si pop ds end; Ładne, dość łatwe i przyjemne :) Teraz coś ambitniejszego: obiekt pozwalający pisać i czytać z pamięci EMS jak z pliku (analogiczny obiekt znajduje się w pakiecie Turbo Vision). Jest tu może jakaś informatyczka?

że przezylam mega orgazm czytajac te wszystkie instrukcje.

a moze ktos sie wypowie...