Come è strutturata la memoria in iOS?

iOS utilizza una struttura gerarchica della memoria con diversi tipi:

1. RAM (Memoria ad accesso casuale):

   • Tipo di memoria veloce e dipendente dall'energia.
   • Usata per memorizzare applicazioni attive e dati.
   • Gestita dal sistema operativo e dal meccanismo ARC (Contatore di riferimenti automatico) per oggetti Swift/Objective-C.
   • In caso di scarsità di memoria, il sistema può chiudere (terminare) le applicazioni meno attive.

2. Memoria incorporata (NAND Flash):

   • Più lenta della RAM, ma non volatile.
   • Usata per memorizzare il sistema operativo, applicazioni, dati utente (foto, video, documenti).
   • Ha una risorsa limitata in termini di cicli di riscrittura.

3. Cache (L1, L2, L3):

   • Memoria molto veloce a livello di processore.
   • Usata per memorizzare istruzioni e dati frequentemente usati per accelerare l'accesso alla RAM.

ARC (Contatore di riferimenti automatico)

• Meccanismo di gestione della memoria in Swift e Objective-C che traccia e gestisce automaticamente i riferimenti agli oggetti.
• Ogni oggetto ha un contatore di riferimenti. Quando raggiunge zero, la memoria occupata dall'oggetto viene liberata.
• Previene perdite di memoria, ma richiede attenzione nel lavorare con cicli di riferimenti forti (strong reference cycles) che possono essere risolti con weak o unowned.

Memoria virtuale

• iOS utilizza memoria virtuale, consentendo ai programmi di usare uno spazio di indirizzamento più grande rispetto alla RAM fisica disponibile.
• Le pagine di memoria possono essere trasferite tra RAM e il file system (limitato in iOS, principalmente tramite la pulizia di pagine non utilizzate, non tramite uno swapping completo su disco come in macOS).
• Meccanismi come la "memoria compressa" possono comprimere le pagine invece di scriverle nello storage.

Gestione della memoria nell'applicazione

• Lo sviluppatore lavora principalmente con la memoria tramite ARC.
• È importante evitare perdite di memoria usando correttamente weak e unowned.
• È necessario ottimizzare il consumo di memoria, ad esempio caricando risorse su richiesta, usando strutture dati efficienti e evitando di creare un numero eccessivo di oggetti.
• Strumenti come Xcode Instruments (Allocations, Leaks) vengono usati per profilare il consumo di memoria e individuare perdite.

Esempio di utilizzo di weak per prevenire cicli di riferimenti forti:

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

    init(name: String) {
        self.name = name
        print("Person \(name) is being initialized")
    }

    deinit {
        print("Person \(name) is being deinitialized")
    }
}

class Apartment {
    let unit: String
    weak var tenant: Person? // Usa 'weak' qui

    init(unit: String) {
        self.unit = unit
        print("Apartment \(unit) is being initialized")
    }

    deinit {
        print("Apartment \(unit) is being deinitialized")
    }
}

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

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

// Se il tenant fosse forte, quando si impostano john e unit4A a nil,
// gli oggetti Person e Apartment non verrebbero deallocati
john = nil // deinit chiamato per john
unit4A = nil // deinit chiamato per unit4A