Mälumudelid

Kõige väikesem mälumudel on tiny. Selle mälumudeli puhul eksisteerib vaid üksainus (kuni 64 KB suurune) segment nii programmi koodi, andmete kui ka pinu jaoks. See mälumudel vastab täpselt DOSi *.COM failide ehitusele. Sellises programmis saab kasutada otsest adresseerimist, s.o. aadress võib olla otseselt masinkoodi osa. Kuna aadress omab vaid segmendisisest osa, siis ei ole aadresside ümberarvutamine programmi alguses (relocation) vajalik. Seepärast töötavad *.COM failid tunduvalt kiiremini kui teised programmid.

Kõik muud mälumudelid vastavad *.EXE failidele. Neist väikseim on small mälumudel. Mälumudeli small puhul omab programm täpselt ühe (kuni 64 KB suuruse) andme- ja ühe samasuure koodisegmendi. Programmi pinu asub tema andmesegmendis. Kuna programm koosneb nüüd vähemalt kahest segmendist, siis tekib programmi mällu laadimisel probleem. Vastavalt sellele, kui palju ohjurprogramme on laaditud, võidakse programm laadida mälus erinevatesse kohtadesse. Ka small mälumudeli puhul ei ole see suurem probleem, kuna te kasutate tavaliselt lühikesi viitasid. Kui te aga kasutaksite mingi muutuja jaoks pikka viita, siis peaks tema aadress koodisegmendis sisaldama ju ka segmendi aadressi. Seda me aga ei tea, sest nagu juba öeldud, laaditakse programm iga kord mälu erinevasse kohta ja seega on segmendiaadressid alati erinevad. Seepärast täidab translaator *.EXE faili pikkade viitade segmendiosad nullidega. Faili algusesse luuakse aga nn. viitade tabel. Selles tabelis on märgitud kõikide pikkade viitade aadressid failis. Kui nüüd operatsioonisüsteem loeb sellise programmi mällu, siis omistab ta registritele mingid kindlad väärtused. Seejärel uurib ta programmi viitade tabelit ja sisestab kõigi pikkade viitade segmendiossa õiged väärtused. Alles nüüd alustatakse programmi täitmist. Seda protsessi nimetatakse aadresside ümberarvutamiseks (relocation) ja selletõttu on *.EXE failide startimine natuke aeglasem. Kui nii võtta, siis on aga iga uus programmeerimistehnika seotud osa töö üleandmisega translaatorile ja teeb seega programmi aeglasemaks. Tänapäeva arvutid on aga küllalt kiired selliste tööde jaoks. Kõige kiirema programmi saaks luua kahtlemata kogu programmi käsitsi masinkoodis kirjutades. Paraku vajab vähegi kasutajasõbraliku programmi käsitsi masinkoodis (või assembleris) kirjutamine nii palju aega ja vaeva, et see lihtsalt ei tasu ära. Peale selle on nii palju tõenäolisem mitmesuguste vigade tekkimine kui translaatori kasutamisel.

Mälumudeli medium puhul kasutab programm kõigi funktsioonidele näitavate viitade puhul pikki (far) ja andmete puhul lühikesi (near) viitasid. Seega võib mälumudelit medium kasutav programm sisaldada kuni 64 KB andmeid ja kuni 1 MB koodi. Selline mudel sobib suurtele keerukatele programmidele, mis aga vajavad vähe andmeid.

Mälumudel compact on mudeli medium täpne vastand. Siin kasutatakse andmete jaoks pikki ja koodi jaoks lühikesi viitasid. Sellist mälumudelit kasutav programm võib kasutada kuni 64 KB koodi (üks segment) ja kuni 1MB andmeid (rohkem segmente). Mälumudel compact sobib suhteliselt väikestele programmidele, mis aga töötlevad suuri andmekoguseid.

Mälumudel large kasutab nii koodi, kui ka andmete jaoks pikki (far) viitasid. Programm võib omada hulgaliselt koodi ja andmesegmente. See võimaldab kasutada nii koodi kui ka andmete jaoks kuni 1 MB mälu.

Suurim mälumudel on huge. See mälumudel kasutab nii koodi kui ka andmete jaoks huge viitasid. Tema põhiline erinevus mudelist large on see, et large mälumudeliga programmid võivad küll omada enam andmesegmente, kuid nad tohivad salvestada oma globaalsed (static) muutujad vaid ühes neist. Seega on globaalsete muutujate maht piiratud 64 KB-ga. Huge mälumudeliga programmide puhul seda piirangut ei ole.

Alltoodud tabelis näete üldistatud kokkuvõtet C - keele mälumudelitest.

Tabel 9: Programmeerimiskeele C mälumudelid

Programmeerimiskeeles C on võimalik kasutada ühes programmis korraga ka erinevaid mälumudeleid. Selline olukord võib tekkida, kui te soovite oma programmis kasutada mingi muu mälumudeliga kompileeritud objektfaili või teeki. Probleemi lahendamiseks tuleb oma programmi sisestada eraldi deklaratsioon iga taolises objektfailis või teegis defineeritud funktsiooni ja muutuja jaoks. Selles deklaratsioonis tuleb võtmesõnade near, far ja huge abil määrata tolle funktsiooni tüüp sõltuvalt tema mälumudelist. Näiteks:

/* Teek.C Selles failis defineerime paar funktsiooni, mida hiljem  */
/* soovime kasutada põhiprogrammis. Selle faili transleerime aga */
/* mälumudeli LARGE abil. Kõik funktsioonid ja andmed vajavad */
/* pikki viitasid */
	/* sümbolite väli. Kuna kasutatakse mälumudelit LARGE, */
	/* siis on tema nimi tegelikult pikk viit */
char	szName[10] = "Peeter";
	/* lihtne funktsioon. Kuna kasutatakse mälumudelit LARGE, */
	/* siis on tema nimi tegelikult pikk viit */
int Func1(char * a, int b) 
{
  ....		/* tee midagi */
  return 2;
}



/* Program.C See on põhiprogramm. Selle faili transleerime mälu- */
/* mudeli SMALL abil. Seega vajavad kõik andmed ja funktsioonid */
/* vaid lühikesi viitasid */
	/* loome vajalikele muutujatele ja funktsioonidele */
	/* sobivad deklaratsioonid vastavad kasutatud mälumudelile */
extern far *szName;
extern int far Func1(char far * a, int b);
	/* nüüd kasutame neid */
void main( void )
{
  char   szBuf[10];
  int	 i;

  fstrcpy((char far*)szBuf, szName);   
  i = Func1((char far*)szBuf, 3);
  ...
}

---