Nordin
"Een model dat niet werkt is erg. Veel erger echter is een model dat werkt, maar waarvan niemand weet waarom"
Hallo beste mensen,
Misschien een hele domme vraag, maar voor wat wordt de stack eigenlijk gebruikt? Ik weet dat het onder ander gebruikt wordt om adresregisters en andere informatie op te slaan in de stack wanneer er bijvoorbeeld een interrupt wordt gegenereerd, of bij een spronginstructie om het adres op te slaan om na een routine terug te springen naar waar het gebleven is. Maar is dat alles waar de stack voor wordt gebruikt? Inprincipe kom je als programmeur zelf niet aan de stack, toch??
Ik hoop zo snel mogelijk een antwoord van jullie te ontvangen, mvg.
Nordin
Op een stack wordt alles gekieperd dat tijdelijk is. In C staan ook je local variables op stack (in C++ soms complete instances...).
Of je er zelf aan komt, is afhankelijk van je programmeertaal. In C of hoger doorgaans niet. In assembly doe je er best veel mee.
Nordin
"Een model dat niet werkt is erg. Veel erger echter is een model dat werkt, maar waarvan niemand weet waarom"
Bedankt Marco,
Maar waar moet ik aan denken in assembleertaal? Kun je een paar voorbeelden van geven dan?
Groetjes!
Henry S.
Moderator
Confucius says chà bù duo. Deze post is niet door ChatGPT gegenereerd. De 2019 CO labvoeding.
Nordin,
De stack is handig om data op te slaan waarvan je één
"exemplaar" hebt per aanroep van een bepaalde functie/subroutine. Voorbeelden daarvan zijn terugkeeraddressen, aanroepparameters en lokale variabelen.
Als je voor dit soort dingen "harde" geheugenlocaties zou gebruiken, dan kan een functie nooit direct of indirect zichzelf aanroepen (recursie). De geheugenlocaties zouden dan immers overschreven worden. Door een stack te gebruiken wordt dit voorkomen.
Zoals Marco schrijft: in een hogere taal maak je je hier geen zorgen over. Stel bijvoorbeeld je schrijft een stukje c code:
void f() {
int x;
}
Dan zorgt de compiler er voor dat op de stack wat ruimte wordt gemaakt voor die int. In assembly moet je dat allemaal zelf doen.
Het gebruik van de stack voor terugkeeraddressen is nog makkelijker, dat gaat hardwarematig en hoef je je zelf als assembly programmeur niet dik over te maken.
Neem een willekeurige assembly tutorial (is zat over te vinden). Naast de reeds genoemde voorbeelden, doen ook veel talen variable passing via de stack. Bij een call wordt (afhankelijk van de taal) eerst het return addres op de stack gemikt, gevolgd door ale variables op een per compiler verschillende manier. De routine zelf kan ze dan zo accessen (en kan dus niet aan 'het origineel' komen). Bij een return worden die variables weer verwijderd (in de praktijk: de stack pointer terug gezet) en een RET gedaan. Komt overigens ook veel andersom voor: eerst variables op de stack, dan de call, daarna opruimen. Voordeel daarvan is dat je je stack op hetzelfde niveau opruimt als opbouwt; vaak wat makkelijker met debuggen.
Groot voordeel is dat er nooit fragmentatie op zal treden: als je een functie uit gaat, wordt alle rommel die daarbij hoort ook opgeruimd. Klein nadeel is dat je moet weten hoe het werkt (en dat is voor veel mensen toch wat hoog gegrepen). Berucht zijn de C functions die een pointer naar een local variable returnen. Syntaxtisch correct, maar erg link en je kunt er uuuuuren naar zoeken voordat je doorhebt waar er wat fout gaat...
Nordin
"Een model dat niet werkt is erg. Veel erger echter is een model dat werkt, maar waarvan niemand weet waarom"
Ok bedankt jongens,
Ik denk dat ik het wel begint te begrijpen, maar om het goed te begrijpen moet ik eigenlijk wat mee spelen.
Dit doet me denken aan geheugen opruimen in C++ m.b.v. new en delete, of alloc en malloc in C. Als je bijv. delete vergeet bij te zetten om een pointer te verwijderen dan kunnen ook gevaarlijke situatie's ontstaan.
In ieder geval erg bedankt mensen, als ik er niet uitkom later, dan kom ik jullie weer lastig vallen 
free_electron
Silicon Member
Professioneel ElectronenTemmer - siliconvalleygarage.com - De voltooid verleden tijd van 'halfgeleider' is 'zand' ... US 8,032,693 / US 7,714,746 / US 7,355,303 / US 7,098,557 / US 6,762,632 / EP 1804159 - Real programmers write Hex into ROM
der worden een paar dingen door elkaar gehaald hier blijkbaar.
de stack ( letterlijk 'stapel' ) wordt gebruikt om dingen SEQUENTIEEL op te slaan. in princiep is een stack NIET random toegankelijk ( het kan door berekeningen te doen gebaseerd op de stack 'pointer' )
de STACK ( de meeste cpu's hebben er slechts 1 , der zijn cpu 's met meerdere , vooral DSP's en zware processoren voor het harde werk ) is niet hetzelfde als het SCRATCH area.
waarvoor wordt de stack gebruikt.
typisch als je een subroutine aanroept. routine 1 is met iets bezig voorbeeld
a=1
b=2
c = addup(a,b)
sub addup
addup=a+b
end sub
hoe werkt de boel nu : de compiler zwikt A en B op de stack.
die stapel groeit dus.
vervolgens wordt er gesprongen nar de subroutine 'addup'
als die routine klaar is moet er ook teruggekeerd worden naar de oorspronkelijk code en daar verdergelopen ... dus wat wordt er gedaan. het terugkeer address wordt ook op die stack gezwikt.
nu springt de processor naar de subroutine. het eerste wat daar gaat gebeuren is het return address van de stack afhalen ( het bovenste element van de stack halen )
vervolgens wordt b en a van de stapel gehaald ( laatst erop is eerst eraf, je moet dit letterlijk zien als een stapel papier )
de subroutine doet haar ding ( al dan niet gebruik makende van scratchgeheugen ) en mikt plaatst het antwoord ook terug op die stapel. als laatste springt de subroutine naar het adress wat het eerst van de stack gehaald heeft.
wanneer we terugkeren wordt het antwoord ( wat nu bovenaan de stapel ligt ) eraf gepluk in in 'c' gesmeten. de stapel is nu teruggekeerd naar zijn originele grotte voordat we al dit spul gedaan hebben.
stacks worden vooral gebruikt om loops te creeren ( recursieve algrotimes bijvoorbeeld werken op het princiepe van een STACK.
nu is het zo dat die stack een LOGISCH concept is. zie het gewoon als een blok geheugen met een extra celletje wat aangeeft waar het laatste element staat. het is de compiler die dit ganse mechanisme beheert. C compilers zijn daar berucht om. die vreten stackruimte omdat dit nu eenmaal hun manier van compileren is.
een PL/1 compile rbijvoorbeeld heeft slechts een heeeel minimale stackruimte nodig omdat die tijdens compile time de addressen uitvlooit die bruikbaar zijn om data te passeren en er helemaal niks doorgegeven wordt via de stack.
het enige wat op de stapel ligt zijn de terugkeeradressen niks anders.
je kan een gigantisch programma hebben wat ene stackje gebruikt wat nooit groter is dan 10 elementen.
opnieuw dit hangt van compiler tot compiler af.
bovendien is neemt iets op een af de stack plukken ook tijd in beslag , maar het spaart al het rekenwerk om de adressen uit te vlooien , je laat dat aan de cpu over.
Nordin
"Een model dat niet werkt is erg. Veel erger echter is een model dat werkt, maar waarvan niemand weet waarom"
Nou erg bedankt F_E,
Nu is het mij toch heel duidelijk, jij bevestigt mijn vermoeden hoe het ongeveer zou werken!
Nogmaals errrrug bedankt!!