Dalvik: τι είναι, η εικονική μηχανή και πώς λειτουργεί

Τι είναι η Dalvik;

Dalvik — εικονική μηχανή με αρχιτεκτονική καταχωρητών, που δημιουργήθηκε ειδικά για την πλατφόρμα Android. Η ανάπτυξη ξεκίνησε το 2005 από την εταιρεία του Νταν Μπόρνσταϊν, και το 2007 το έργο εξαγοράστηκε από την Google. Η πρώτη εμπορική έκδοση της Dalvik εμφανίστηκε μαζί με την κυκλοφορία του Android 1.0 το 2008.

Σε αντίθεση με την τυπική Java Virtual Machine (JVM), η Dalvik δεν εκτελεί byte-code της Java. Ο μεταγλωττιστής Java μετατρέπει τον πηγαίο κώδικα σε αρχεία class, και στη συνέχεια το εργαλείο dx τα μετατρέπει στη μορφή Dalvik Executable (DEX). Αυτή η μορφή είναι πιο συμπαγής από τα αρχεία class: μια εφαρμογή μεγέθους 10 MB σε μορφή class καταλαμβάνει περίπου 6–7 MB σε DEX.

Ιστορία της δημιουργίας

Ο Νταν Μπόρνσταϊν έγραψε τη Dalvik ως έργο για λειτουργικά συστήματα με περιορισμένους πόρους. Το όνομα προέρχεται από το ισλανδικό χωριό Ντάλβικ. Η Google επέλεξε τη Dalvik αντί της JVM λόγω περιορισμών αδειοδότησης και της ανάγκης για βαθιά βελτιστοποίηση για επεξεργαστές κινητών με αρχιτεκτονική ARM. Το σύστημα κέρδισε γρήγορα δημοτικότητα: μέχρι το 2012 πάνω από 500 εκατομμύρια συσκευές Android λειτουργούσαν με τη Dalvik.

Ο ρόλος της στο οικοσύστημα Android

Κάθε εφαρμογή Android εκτελείται σε ξεχωριστή διαδικασία με δικό της στιγμιότυπο VM της Dalvik. Αυτό εξασφαλίζει την απομόνωση των δεδομένων και την προστασία από κακόβουλο κώδικα σε επίπεδο λειτουργικού συστήματος. Αυτή η προσέγγιση συνδυάζει τα πλεονεκτήματα της εικονικοποίησης με το sandbox του Linux — το κακόβουλο λογισμικό σε μια εφαρμογή δεν μπορεί να επηρεάσει τις γειτονικές διαδικασίες.

Αρχιτεκτονική της Dalvik: μηχανή καταχωρητών και DEX

Η αρχιτεκτονική καταχωρητών της Dalvik διαφέρει θεμελιωδώς από την αρχιτεκτονική στοίβας της JVM. Αντί για λειτουργίες στην κορυφή της στοίβας, η Dalvik λειτουργεί με καταχωρητές — εικονικά κελιά μέσα στη VM. Κάθε εντολή περιέχει τις διευθύνσεις των καταχωρητών-τελεστέων, γεγονός που μειώνει τον αριθμό των εντολών ανά λειτουργία.

Η μηχανή στοίβας της JVM χρησιμοποιεί εντολές όπως push, pop και add — για την πρόσθεση δύο αριθμών απαιτούνται τρεις εντολές. Η Dalvik λύνει το ίδιο πρόβλημα με μία εντολή add-int με τρεις καταχωρητές. Σύμφωνα με τα στοιχεία του Android Open Source Project, η αρχιτεκτονική καταχωρητών του DEX μειώνει τον όγκο του byte-code κατά μέσο όρο 30% σε σύγκριση με τη μορφή class με βάση τη στοίβα.

Μορφή DEX

Το αρχείο DEX (Dalvik Executable) περιέχει συμπιεσμένη αναπαράσταση όλων των κλάσεων της εφαρμογής. Η επικεφαλίδα του αρχείου περιλαμβάνει άθροισμα ελέγχου, μεγέθη τμημάτων και μετατοπίσεις. Τα κύρια τμήματα είναι οι πίνακες συμβολοσειρών, τύπων, πρωτοτύπων μεθόδων, πεδίων και ο ίδιος ο byte-code. Σε ένα αρχείο DEX μπορούν να αποθηκευτούν έως και 65536 μέθοδοι (ο περιορισμός αρθηκε με την εισαγωγή του multi-dex στο Android 5.0).

Για τη μετατροπή αρχείων class σε DEX χρησιμοποιείται το εργαλείο dx, που περιλαμβάνεται στο Android SDK Build Tools. Παράδειγμα εντολής: dx --dex --output=classes.dex myapp.jar. Τα σύγχρονα έργα χρησιμοποιούν το D8 — τον διάδοχο του dx με βελτιωμένη βελτιστοποίηση και υποστήριξη δυνατοτήτων Java 8+.

# Μετατροπή JAR σε DEX με το dx
dx --dex --output=classes.dex myapp.jar

# Σύγχρονη έκδοση μέσω D8
d8 --lib android.jar --output dex/ myapp.jar

Zygote: προφόρτωση του πλαισίου

Η διαδικασία Zygote είναι το σημαντικότερο στοιχείο της αρχιτεκτονικής της Dalvik. Κατά την εκκίνηση του συστήματος, η Zygote φορτώνει όλες τις κλάσεις του Android SDK, ανοίγει κοινές βιβλιοθήκες και δημιουργεί μια δεξαμενή πόρων preload. Όταν ο χρήστης ανοίγει μια εφαρμογή, το σύστημα αντιγράφει τη διαδικασία Zygote (fork), δημιουργώντας ένα νέο στιγμιότυπο VM της Dalvik με ήδη έτοιμο το πλαίσιο. Αυτό μειώνει τον χρόνο εκκίνησης της εφαρμογής από ~2–3 δευτερόλεπτα σε 300–500 χιλιοστά του δευτερολέπτου.

Μεταγλώττιση JIT στη Dalvik

JIT (Just-In-Time) — τεχνολογία μεταγλώττισης byte-code σε εντολές μηχανής απευθείας κατά την εκτέλεση της εφαρμογής. Στη Dalvik, ο μεταγλωττιστής JIT αναλύει τον εκτελούμενο κώδικα DEX, εντοπίζει τις συχνά χρησιμοποιούμενες (hot) μεθόδους και τις μεταγλωττίζει σε εγγενή κώδικα για τη CPU.

Η επιλογή του JIT αντί της πλήρους μεταγλώττισης Ahead-Of-Time (AOT) στις πρώιμες εκδόσεις του Android ήταν σκόπιμη. Οι κινητές συσκευές είχαν περιορισμένη μνήμη flash (4–16 GB) — η εκ των προτέρων μεταγλώττιση όλων των εφαρμογών θα καταλάμβανε σημαντικό χώρο. Επιπλέον, η μνήμη ROM στις πρώιμες συσκευές ήταν πιο αργή από τη μνήμη RAM, και η ανάγνωση προμεταγλωττισμένου κώδικα θα μπορούσε να μειώσει την απόδοση.

Διαδικασία μεταγλώττισης JIT

Όταν εκκινείται μια εφαρμογή, η Dalvik αρχίζει να διερμηνεύει τον byte-code DEX. Ένας ειδικός αναλυτής προφίλ παρακολουθεί ποιες μέθοδοι καλούνται συχνότερα. Μετά την υπέρβαση του ορίου (συνήθως ~200 κλήσεις), ο μεταγλωττιστής JIT μετατρέπει τη μέθοδο σε κώδικα μηχανής και τον αποθηκεύει στην προσωρινή μνήμη RAM. Οι επόμενες κλήσεις χρησιμοποιούν την ήδη μεταγλωττισμένη έκδοση χωρίς εκ νέου μεταγλώττιση.

// Παράδειγμα hot-μεθόδου που θα μεταγλωττίσει η JIT
public class Calculator {
    public int sumArray(int[] arr) {
        int total = 0;
        for (int i = 0; i < arr.length; i++) {
            total += arr[i];
        }
        return total;
    }
}

Απόδοση της JIT

Σύμφωνα με τα στοιχεία του Google I/O 2013, η εισαγωγή του JIT στο Android 2.2 Froyo επιτάχυνε την εκτέλεση εφαρμογών κατά μέσο όρο 2–5 φορές σε σύγκριση με την καθαρή διερμηνεία. Ωστόσο, το JIT προσθέτει καθυστέρηση κατά την πρώτη εκκίνηση: η εφαρμογή χρειάζεται από 3 έως 10 δευτερόλεπτα για την προθέρμανση και τη μεταγλώττιση των hot μεθόδων. Μετά την προθέρμανση, η απόδοση σταθεροποιείται σε επίπεδο κοντά στον εγγενή κώδικα.

Dalvik vs JVM: βασικές διαφορές

Η Dalvik διαφέρει από τη JVM σε αρκετές θεμελιώδεις παραμέτρους. Πρώτον — η αρχιτεκτονική: η JVM βασίζεται στη στοίβα, η Dalvik στους καταχωρητές. Δεύτερον — η μορφή byte-code: η JVM χρησιμοποιεί αρχεία class, η Dalvik — DEX. Τρίτον — η διαχείριση μνήμης: η Dalvik είναι βελτιστοποιημένη για τον περιορισμένο όγκο RAM των κινητών συσκευών.

Και οι δύο προσεγγίσεις έχουν δυνατά σημεία. Η JVM με βάση τη στοίβα απαιτεί λιγότερο χώρο για την αποθήκευση εντολών — κάθε εντολή είναι πιο σύντομη, καθώς οι τελεστές λαμβάνονται σιωπηρά από τη στοίβα. Η Dalvik με βάση τους καταχωρητές εκτελεί λιγότερες εντολές ανά λειτουργία, γεγονός που εξοικονομεί χρόνο CPU και μειώνει την κατανάλωση ενέργειας. Για κινητές συσκευές που λειτουργούν με μπαταρία, αυτό είναι κρίσιμο.

Ζητήματα αδειοδότησης

Η επιλογή της Dalvik αντί της JVM οφειλόταν επίσης στη χορήγηση αδειών. Η Oracle κατέχει τα δικαιώματα για τη Java SE και τη JVM, και η Google επιδίωκε να αποφύγει τα τέλη αδειοδότησης. Η δημιουργία δικής της VM με εναλλακτική μορφή byte-code επέτρεψε στο Android να αναπτύσσεται ανεξάρτητα από την Oracle. Αυτή η διαφορά οδήγησε σε πολυετή δικαστική διαμάχη Oracle vs Google (2010–2021), που ολοκληρώθηκε υπέρ της Google.

Μορφή DEX και εργαλείο dx

DEX (Dalvik Executable) — δυαδική μορφή που περιέχει τον μεταγλωττισμένο κώδικα της εφαρμογής Android. Κάθε αρχείο DEX ξεκινά με επικεφαλίδα (header), την οποία ακολουθούν τα τμήματα: σταθερές συμβολοσειρών (string_ids), τύποι (type_ids), πρωτότυπα μεθόδων (proto_ids), πεδία (field_ids), μέθοδοι (method_ids), ορισμοί κλάσεων (class_defs) και η περιοχή δεδομένων (data).

Το εργαλείο dx μετατρέπει τα αρχεία class της Java σε ένα ή περισσότερα αρχεία DEX. Ο αλγόριθμος λειτουργίας περιλαμβάνει αφαίρεση διπλοτύπων σταθερών — οι ίδιες συμβολοσειρές ή τύποι αποθηκεύονται μία φορά και αναφέρονται με ευρετήριο. Αυτό μειώνει σημαντικά το τελικό μέγεθος. Στα σύγχρονα έργα το dx αντικαταστάθηκε από το D8 (εμφανίστηκε στο Android Studio 3.1), το οποίο λειτουργεί 2–3 φορές γρηγορότερα και υποστηρίζει τη διαχωρισμό (desugaring) της Java 8.

// Παράδειγμα απομεταγλωττισμένου byte-code DEX μέσω dexdump
// Πηγαίος κώδικας: return a + b;
@Ldalvik/annotation/Code;
    registers: 3
    add-int v0, v1, v2
    return v0

Multi-dex: υπέρβαση του ορίου 65536

Ο περιορισμός της μορφής DEX στις 65536 μεθόδους (όριο του 16-μπιτου ευρετηρίου) αποτέλεσε σοβαρό πρόβλημα για μεγάλες εφαρμογές. Η λύση εμφανίστηκε στο Android 5.0: η υποστήριξη multi-dex επιτρέπει στην εφαρμογή να περιέχει πολλά αρχεία DEX. Το κύριο classes.dex περιέχει τα σημεία εισόδου, ενώ τα πρόσθετα classes2.dex, classes3.dex και ούτω καθεξής — τον υπόλοιπο κώδικα. Η ρύθμιση multi-dex ενεργοποιείται στο build.gradle με τη γραμμή multiDexEnabled true.

Διαχείριση μνήμης και συλλογή απορριμμάτων

Η συλλογή απορριμμάτων στη Dalvik υλοποιείται ως γενεαλογικός (generational) συλλέκτης με σήμανση και καθαρισμό (mark-and-sweep). Η μνήμη χωρίζεται σε δύο κύριες περιοχές: Heap (σωρό) για τα αντικείμενα και Stack (στοίβα) για τα πρωτογενή δεδομένα και τις αναφορές. Όταν γεμίζει το Heap, η Dalvik αναστέλλει όλα τα νήματα (STW — Stop-The-World), σημαδεύει τα προσβάσιμα αντικείμενα και απελευθερώνει τα μη προσβάσιμα.

Μέχρι το Android 2.2 η Dalvik χρησιμοποιούσε μονονηματικό συλλέκτη με διάρκεια παύσης έως 100–200 ms. Στο Android 2.3 Gingerbread εμφανίστηκε ο concurrent-συλλέκτης, που μείωσε τις τυπικές παύσεις σε 5–10 ms. Και στο Android 4.0 Ice Cream Sandwich προστέθηκε συλλέκτης με μερικό (incremental) καθαρισμό — Concurrent Mark and Sweep (CMS).

Διαρροές μνήμης

Τυπικό πρόβλημα των εφαρμογών Dalvik — οι διαρροές μνήμης μέσω στατικών αναφορών σε Activity. Εάν ένα στατικό πεδίο διατηρεί αναφορά σε Context ή View, ο συλλέκτης απορριμμάτων δεν μπορεί να απελευθερώσει το Activity ακόμη και μετά το κλείσιμο της οθόνης. Εργαλεία όπως το Eclipse MAT και το LeakCanary βοηθούν στον εντοπισμό τέτοιων διαρροών: αναλύουν το dump του Heap και δείχνουν τις αλυσίδες αναφορών που συγκρατούν το αντικείμενο.

// Παράδειγμα διαρροής μνήμης μέσω στατικής αναφοράς
public class Utils {
    private static Context context;

    public static void init(Context ctx) {
        context = ctx; // Συγκρατεί το Activity μετά το finish()
    }
}

Περιορισμοί της Dalvik και μετάβαση στο ART

Παρά την επιτυχία της, η Dalvik είχε μια σειρά μειονεκτημάτων. Η μεταγλώττιση JIT απαιτούσε χρόνο προθέρμανσης — τα πρώτα δευτερόλεπτα λειτουργίας της εφαρμογής ήταν πιο αργά. Επιπλέον, το JIT κατανάλωνε ενέργεια του επεξεργαστή κατά τη μεταγλώττιση, γεγονός που μείωνε τον χρόνο αυτόνομης λειτουργίας. Με την αύξηση της απόδοσης των κινητών συσκευών και την αύξηση του όγκου της ενσωματωμένης μνήμης, η ανάγκη για JIT μειώθηκε.

Στο Android 4.4 KitKat η Google παρουσίασε το ART (Android Runtime) ως πειραματική αντικατάσταση της Dalvik. Από το Android 5.0 Lollipop το ART έγινε το μοναδικό περιβάλλον εκτέλεσης. Η κύρια διαφορά — η μεταγλώττιση AOT: αντί να μεταγλωττίζεται κατά τη λειτουργία, όλες οι εφαρμογές μεταγλωττίζονται σε κώδικα μηχανής κατά την εγκατάσταση. Αυτό εξάλειψε τις καθυστερήσεις προθέρμανσης και βελτίωσε την ενεργειακή απόδοση.

Αντίστροφη συμβατότητα

Η μετάβαση από τη Dalvik στο ART ήταν διαφανής για τους προγραμματιστές: και τα δύο περιβάλλοντα εκτελούν τον ίδιο byte-code DEX. Οι εφαρμογές που δημιουργήθηκαν για τη Dalvik λειτουργούν στο ART χωρίς εκ νέου μεταγλώττιση — το system_server τις μεταγλωττίζει σε εγγενή κώδικα κατά την εγκατάσταση. Εξαίρεση αποτελεί ο κώδικας που χρησιμοποιεί αντανάκλαση (reflection) για πρόσβαση σε εσωτερικά μέλη της VM της Dalvik: τέτοιος κώδικας μπορούσε να χαλάσει στο ART λόγω αλλαγής της εσωτερικής αρχιτεκτονικής.