Kuidas on iOS-is mälu üles ehitatud?

iOS kasutab hierarhilist mälu struktuuri, millel on mitu tüüpi:

1. RAM (Juhuslik Puhvermälu):

   • Kiire, energiasõltuv tüüp mälu.
   • Kasutatakse aktiivsete rakenduste ja andmete salvestamiseks.
   • Hallatakse operatsioonisüsteemi ja ARC (Automaatne Viidete Arvutamine) mehhanismi kaudu Swift/Objective-C objektidele.
   • Mälu puudusel võib süsteem vähese aktiivsusega rakendused välja logida (lõpetada).

2. Sisseehitatud Mälu (NAND Flash):

   • Aeglasem kui RAM, kuid energiasõbralik.
   • Kasutatakse operatsioonisüsteemi, rakenduste ja kasutaja andmete (foto, video, dokumendid) salvestamiseks.
   • Piiratud kirjutamistsüklite arv.

3. Kohalik Mälu (L1, L2, L3):

   • Väga kiire mälu protsessori tasandil.
   • Kasutatakse sageli kasutatavate juhiste ja andmete salvestamiseks, et kiirendada juurdepääsu RAM-ile.

ARC (Automaatne Viidete Arvutamine)

• Mälu haldamise mehhanism Swift ja Objective-C keeles, mis automaatselt jälgib ja haldab objektidele viiteid.
• Igal objektil on viidete arv. Kui see jõuab nulli, vabastatakse objekti poolt hõivatud mälu.
• Vältib mälu lekked, kuid nõuab tähelepanu tsükliliste tugevate viidete (strong reference cycles) korral, mida saab lahendada weak või unowned viidetega.

Virtuaalmälu

• iOS kasutab virtuaalmälu, võimaldades programmide kasutada suuremat aadressiruumi kui füüsiliselt olemasolev RAM.
• Mälu lehed võivad liikuda RAM-i ja failisüsteemi vahel (kuigi iOS-is toimub see piiratud ulatuses, peamiselt kasutamata lehtede puhastamise kaudu, mitte täieliku vahetamisega kettale nagu macOS-is).
• Mekanismid nagu "surutud mälu" võivad lehti tihendada, selle asemel et kirjutada need salvestusruumi.

Mälu Halduse Põhimõtted Rakenduses

• Arendaja töötab peamiselt ARC kaudu.
• Oluline on vältida mälu lekked, kasutades õigesti weak ja unowned.
• Mälu kasutust tuleb optimeerida, näiteks laadides ressursse nõudmisel, kasutades tõhusaid andmestruktuure ja vältides liigsete objektide loomist.
• Tööriistad nagu Xcode Instruments (Allocations, Leaks) aitavad mälu kasutust profilleerida ja lekked leida.

Näide weak kasutamisest tugevate viidete tsükli vältimiseks:

class Person {
    let name: String
    var apartment: Apartment?

    init(name: String) {
        self.name = name
        print("Person \(name) on initsialiseeritud")
    }

    deinit {
        print("Person \(name) on de-initsialiseeritud")
    }
}

class Apartment {
    let unit: String
    weak var tenant: Person? // Kasuta 'weak' siin

    init(unit: String) {
        self.unit = unit
        print("Apartment \(unit) on initsialiseeritud")
    }

    deinit {
        print("Apartment \(unit) on de-initsialiseeritud")
    }
}

var john: Person? = Person(name: "John Appleseed")
var unit4A: Apartment? = Apartment(unit: "4A")

john?.apartment = unit4A
unit4A?.tenant = john

// Kui tenant oleks tugev viide, siis objekti Person ja Apartment kustutamisel
// need ei de-initsialiseeruks
john = nil // deinit kutsutakse john jaoks
unit4A = nil // deinit kutsutakse unit4A jaoks