Hoe is de stack opgebouwd in de Go-taal?

In Golang is de heap een geheugenruimte waar dynamisch toegewezen objecten worden geplaatst. Het beheer van dit geheugen wordt automatisch gedaan door de garbage collector.

Belangrijke aspecten:

• Dynamische toewijzing: Kleine objecten en objecten met korte levensduur, waarbij de compiler niet kan bewijzen dat hun levensduur beperkt is door de grenzen van de functie of de stack, of die worden toegewezen met new of door het nemen van het adres (&), worden meestal op de heap geplaatst.
• Garbage Collector (GC): Go gebruikt een gelijktijdige, driekleuren, Mark-and-Sweep garbage collector. Het werkt parallel aan de uitvoering van het programma en minimaliseert pauzes.
  • Markeren (Mark): De GC doorloopt bereikbare objecten vanaf de root pointers (lokale variabelen op de stacks, globale variabelen) en markeert ze als "levend".
  • Schoonmaken (Sweep): De GC doorloopt de hele toegankelijke heap en vrijmaakt het geheugen dat wordt ingenomen door niet-gemarkeerde "levende" objecten.
  • Gelijktijdig: De GC werkt in aparte goroutines, waardoor vertragingen in het hoofdprogramma worden verminderd.
• Escape-analyse: De Golang-compiler voert een analyse uit (escape analysis) om te bepalen of een variabele of waarde wijst naar de stack of de heap. Als een variabele of structureel veld na de terugkeer uit de huidige goroutine toegankelijk kan zijn, wordt deze waarschijnlijk op de heap geplaatst. Anders kan het op de stack worden geplaatst.

  // Voorbeeld van escape-analyse.
  // Dit object wordt waarschijnlijk op de heap geplaatst,
  // omdat er een pointer wordt geretourneerd.
  func createPoint() *Point {
      p := Point{X: 1, Y: 2}
      return &p // Pointer "ontsnapt" uit de functie
  }
  
  // Dit object wordt waarschijnlijk op de stack geplaatst,
  // omdat het niet toegankelijk is na het voltooien van de functie.
  func processValue() {
      val := 10
      println(val)
  }
  
  type Point struct {
      X, Y int
  }
  

• Verdeling in arena's: De heap in Go kan worden verdeeld in meerdere arena's, wat de garbage collector helpt efficiënter te werken, vooral op systemen met meerdere processoren.
• Gebruik van mmap: Golang gebruikt de systeemaanroep mmap (Memory Map) om grote virtuele geheugenblokken toe te wijzen voor de heap.
• Continuïteit: In tegenstelling tot sommige talen garandeert Go niet de fysieke continuïteit van objecten op de heap. Het geheugen kan gefragmenteerd zijn.
• Gebrek aan handmatig geheugenbeheer: Ontwikkelaars hoeven geheugen niet expliciet toe te wijzen of vrij te geven op de heap. GC doet dit automatisch.

De stack en de heap in Golang vervullen verschillende rollen:

Geheugenruimte	Doel	Beheer	Levensduur
Stack	Lokale variabelen, functiewaarden, retouradressen	Automatisch (bij binnenkomst/uitgang van een functie)	Beperkt tot de uitvoeringstijd van de functie
Heap	Dynamisch toegewezen objecten, die "ontsnappen" uit de stack, grote structuren	Garbage collector (GC)	Bepaald door de bereikbaarheid van het object vanaf de roots