De scheduler van de kernel zorgt voor het verdelen van de tijd over de processen. Je besturingssysteem moet ze ook qua ruimte verdelen, zodanig dat processen niet in elkaars werkgeheugen kunnen gaan zitten. Zelfs als je er van uit gaat dat alle programma's proberen samen te werken, wil je niet dat een bug in het ene programma de andere programma's kan beschadigen. Datgene dat je besturingssysteem doet om dit probleem op te lossen wordt geheugenbeheer genoemd.
Ieder proces in je dierentuin heeft z'n eigen gebied in het geheugen nodig, als een plaats van waaruit het z'n code kan uitvoeren en variabelen en resultaten in op kan slaan. Je kunt je dit voorstellen als een alleen leesbaar code segment (waar de instructies van het proces in staan) en een schrijfbaar data segment (waarin alle variabelen van het proces zijn opgeslagen). Het data segment is waarlijk uniek voor ieder proces, maar als twee processen dezelfde code uitvoeren, herschikt Unix ze automatisch zodanig dat ze een enkel codesegment delen als een efficiëntie maatregel.
Efficiëntie is belangrijk, omdat geheugen duur is. Soms heb je niet genoeg om het geheel aan programma's die op de computer worden gedraaid, vast te houden, vooral als je een groot programma zoals een X server gebruikt. Om dit te ontduiken, gebruikt Unix een strategie die virtueel geheugen wordt genoemd. Het probeert niet alle code en data voor een proces in het geheugen te behouden. In plaats daarvan, blijft het werken met een relatief kleine werkset; de rest van de stand van het proces blijft achter in een speciaal swap space gebied op je harddisk.
Als het proces draait, probeert Unix vooruit te lopen op hoe de werkset zal wijzigen en heeft slechts hetgeen het nodig heeft in het geheugen. Dit doeltreffend doen is zowel gecompliceerd als lastig, dus ik zal niet proberen het hier allemaal te beschrijven, -- maar het hangt af van het feit dat code en dataverwijzingen geneigd zijn in clusters te gebeuren, waarbij het aannemelijk is dat iedere nieuwe cluster naar een oude cluster in de buurt ervan verwijst. Dus als Unix de code of data die het vaakst (of meest recent) wordt gebruikt, in de buurt houdt, zal het er gewoonlijk in slagen tijd te besparen.
Merk op dat in het verleden, dat "Soms" twee paragrafen terug "Bijna altijd" was, -- de grootte van het geheugen was kenmerkend klein gerelateerd aan de grootte van uitvoerende programma's, dus er werd frequent geswapt. Geheugen is tegenwoordig veel minder duur en zelfs de goedkoopste computers hebben er heel veel van. Op moderne single-user computers met 64MB of meer geheugen, is het mogelijk om X te draaien en een typische mix taken zonder ooit te swappen.
Zelfs in deze gelukkige situatie, heeft het deel van het besturingssysteem dat geheugenbeheer wordt genoemd, nog steeds belangrijk werk te doen. Het moet ervoor zorgen dat programma's alleen hun eigen datasegmenten kunnen wijzigen --dat wil zeggen, voorkomen dat door onjuiste of kwaadwillige code in het ene programma de data in een ander programma overhoop wordt gehaald. Om dit te doen, houdt het een tabel met gegevens en codesegmenten bij. De tabel wordt bijgewerkt als een proces om meer geheugen verzoekt of geheugen vrijgeeft (het laatste meestal als het stopt).
Deze tabel wordt gebruikt om commando's door te geven naar een gespecialiseerd deel van de onderliggende hardware met de naam MMU of memory management unit. MMU's zijn bovenop moderne processor chips gebouwd. De MMU heeft de speciale mogelijkheid om geheugengebieden af te schermen, dus een buiten-de-grens verwijzing zal worden geweigerd en een speciale interrupt veroorzaken.
Als je ooit een Unix melding "Segmentation fault", "core dumped" of iets vergelijkbaars te zien krijgt, is dit wat er precies is gebeurd; een poging van het uitvoerende programma om toegang tot het geheugen (de core) buiten zijn segment te verkrijgen, heeft een fatale interrupt veroorzaakt. Dit duidt op een bug in de programmacode; de core dump die het achterlaat bestaat uit diagnostische informatie met de bedoeling de programmeur te helpen het op te sporen.
Er is nog een aspect om ervoor te zorgen processen tegen elkaar te beschermen, buiten het opdelen van het geheugen dat ze benaderen. Je zal ook de toegankelijkheden van de bestanden willen beheren, zodat een programma met fouten of een kwaadwillig programma kritieke delen van het systeem niet kan beschadigen. Daarom bestaan er onder Unix bestandspermissies, die we later zullen bespreken.