Что такое Dart VM?

Что такое Dart VM?

Dart VM (Virtual Machine) — это виртуальная машина, на которой выполняется код Dart. Это мощный интерпретатор/компилятор, который отвечает за выполнение, оптимизацию и управление памятью Dart программ.

Архитектура Dart VM

Исходный код Dart
        ↓
    Parser (Парсер)
    ↓        ↓
AST (Abstract Syntax Tree)
    ↓
  Analyzer (Анализ типов)
    ↓
Intermediate Representation (IR)
    ↓
  JIT Compiler (Just-In-Time)
    ↓
  Dart VM Runtime
    ↓
Machine Code (на вашем процессоре)

Что делает Dart VM?

// 1. Компиляция кода
void main() {
  int x = 5;
  int y = 10;
  print(x + y);  // 15
}

// Dart VM:
// а) Парсит текст исходного кода
// б) Проверяет типы (int + int = int)
// в) Компилирует в машинный код
// г) Оптимизирует на лету
// д) Выполняет

// 2. Управление памятью
// - Распределение памяти для объектов
// - Сборка мусора (Garbage Collection)
// - Оптимизация использования памяти

// 3. Оптимизация
// - Встраивание методов (inlining)
// - Удаление мёртвого кода
// - Speculative optimization

JIT vs AOT Компиляция в Dart VM

// DEVELOPMENT MODE (JIT - Just-In-Time)
// ✅ Быстрая компиляция
void main() {
  print('Hello World');
  // Код компилируется во время выполнения
  // flutter run --debug
}

// Процесс:
// 1. flutter run прочитает исходный код
// 2. Dart VM скомпилирует на лету
// 3. Выполнит немедленно
// 4. Hot reload перезагружает только изменённый код

// Результат: ⚡ Очень быстрый цикл разработки

// PRODUCTION MODE (AOT - Ahead-Of-Time)
// ✅ Максимальная производительность
// flutter run --release

// Процесс:
// 1. flutter build скомпилирует весь код заранее
// 2. Создаст нативный бинарник (APK/IPA)
// 3. На телефоне выполняется уже готовый машинный код
// 4. Нет overhead компиляции при запуске

// Результат: ⚡⚡ Очень быстрый старт приложения

Как Dart VM оптимизирует код

1. Inlining (встраивание методов)

// ❌ БЕЗ оптимизации
int add(int a, int b) => a + b;
int multiply(int a, int b) => a * b;

int calculate(int x, int y) {
  return add(x, y) + multiply(x, 2);  // 2 вызова функций
}

// Каждый вызов функции требует:
// - Сохранения регистров
// - Создания stack frame
// - Прыжка на адрес функции
// = Замедление

// ✅ С оптимизацией (Inlining)
// Dart VM преобразует в:

int calculate(int x, int y) {
  return (x + y) + (x * 2);  // Прямой код, вызовов нет!
}

// Результат: Нет overhead вызовов функций

2. Type Specialization

// ✅ Dart VM создаёт специализированный код

class Box<T> {
  final T value;
  Box(this.value);
  
  T getValue() => value;  # Generics
}

void main() {
  final intBox = Box<int>(42);   # Box<int>
  final stringBox = Box<String>('hello');  # Box<String>
  
  // Dart VM создаёт ДВА варианта функции getValue:
  // 1. Box<int>.getValue() -> быстрый, знает тип
  // 2. Box<String>.getValue() -> быстрый, знает тип
  
  // Результат: Нет затрат на работу с generic типами
}

3. Dead Code Elimination

// ❌ Мёртвый код
const DEBUG = false;

void main() {
  if (DEBUG) {  # Известно на compile-time что false!
    print('Debug info 1');
    print('Debug info 2');
    print('Debug info 3');
    // Много строк кода
  }
  
  print('Actual code');
}

// ✅ Dart VM удаляет весь if блок
// Скомпилированный код:

void main() {
  print('Actual code');
}

// Результат: Меньше кода = быстрее и компактнее

Сборка мусора (Garbage Collection)

// Dart VM использует generational GC

// Young Generation (молодое поколение)
// - Малый размер (легко в CPU кэше)
// - Часто собирается (каждые миллисекунды)
// - Очень быстро (< 10ms обычно)

final tempList = <int>[1, 2, 3];  # Временный список
print(tempList);  # Сразу удаляется

// Old Generation (старое поколение)
// - Большой размер
// - Редко собирается (когда молодого недостаточно)
// - Медленнее, но редко происходит

final persistentList = <int>[];  # Долгоживущий объект
for (int i = 0; i < 1000000; i++) {
  persistentList.add(i);
}

// Результат:
// - UI остаётся отзывчивым (молодые объекты быстро удаляются)
// - Эффективное использование памяти
// - 60-120 fps на мобильных устройствах

Event Loop в Dart VM

// Dart VM управляет event loop

void main() async {
  print('1. Start');  # Синхронно
  
  Future.microtask(() => print('2. Microtask'));  # Высокий приоритет
  
  Future.delayed(Duration.zero, () => print('3. Event'));  # Событие
  
  Timer(Duration(seconds: 1), () => print('4. Timer 1s'));  # Таймер
  
  print('5. End');  # Синхронно
}

// Event Loop цикл в Dart VM:
// 1. Выполни весь синхронный код
// 2. Выполни все microtask'и
// 3. Выполни одно событие из event queue
// 4. Повтори

// Вывод:
// 1. Start
// 5. End
// 2. Microtask
// 3. Event
// 4. Timer 1s

Null Safety в Dart VM

// Null Safety — это не просто проверка типов
// Это позволяет Dart VM делать агрессивные оптимизации

// ❌ Старый Dart (с nullable всюду)
String name = null;  # Может быть null
print(name.length);  # Runtime error!

// Dart VM не может оптимизировать (может быть null)

// ✅ Dart 2.12+ (с null safety)
String name = 'John';  # Не может быть null!
String? optionalName = null;  # Только с ?

print(name.length);  # Dart VM ЗНАЕТ, что name не null
// Может удалить null check перед обращением к length

// Результат: Быстрее выполнение благодаря меньшим проверкам

Dart VM vs JavaScript Engine

Dart VM                          | JavaScript Engine (V8)
─────────────────────────────────┼──────────────────────────
Strong typing                    | Dynamic typing
JIT + AOT компиляция             | Только JIT
Generational GC (эффективный)    | Mark-and-sweep GC
Microtask queue поддержка        | Через Promise
Optimization = быстрее           | Optimization = сложнее
APK/IPA (нативный бинарник)      | JavaScript текст
Из коробки: 120 fps              | С трудом: 60 fps

Структура Dart VM

Dart VM
├── Isolate (отдельный поток исполнения)
│   ├── Heap (памяти для объектов)
│   ├── Stack (локальные переменные)
│   ├── Event Queue (события)
│   └── Microtask Queue (микротаски)
├── Collector (сборщик мусора)
├── Compiler (JIT компилятор)
├── Scheduler (планировщик задач)
└── Runtime Library (стандартная библиотека)

Практическое влияние Dart VM

// 1. Hot Reload благодаря JIT
class MyWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Text('Version 1');
    // Меняешь на 'Version 2'
    // Hot reload перекомпилирует только этот файл
    // Мгновенно видишь изменение!
  }
}

// 2. Performance в production
class ListView extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ListView.builder(
      itemCount: 10000,  # 10000 элементов
      itemBuilder: (context, index) {
        // Благодаря Dart VM optimizations:
        // - Встраивание методов
        // - Удаление мёртвого кода
        // - Специализация типов
        // = Плавный скроллинг на любом устройстве
        return Text('Item $index');
      },
    );
  }
}

// 3. Управление памятью
Future<void> processLargeData() async {
  final largeList = <int>[for (int i = 0; i < 1000000; i++) i];
  
  // Благодаря GC в Dart VM:
  // - Создание списка быстрое
  // - Удаление быстрое
  // - Никакого утечек памяти (обычно)
  
  await Future.delayed(Duration(seconds: 1));
  
  // largeList автоматически удаляется
  // Memoria освобождается
}

Инструменты для работы с Dart VM

# DevTools — графический интерфейс
flutter pub global activate devtools
flutter pub global run devtools

# Анализ памяти
flutter run --profile
# В DevTools → Memory tab

# Анализ производительности
flutter run --profile
# В DevTools → Performance tab

# Профилирование CPU
flutter run --profile
# В DevTools → CPU Profiler

# Просмотр код IR
dart --print-ir my_program.dart

Резюме

Dart VM — это:

1. Компилятор + Интерпретатор — JIT в разработке, AOT в production
2. Оптимизатор — inlining, specialization, dead code elimination
3. Memory Manager — generational GC, эффективное управление
4. Runtime Environment — event loop, isolates, async/await

Почему Dart VM быстрый?

• ✅ JIT оптимизирует на основе реального выполнения
• ✅ AOT компилирует в нативный код
• ✅ Generational GC очень эффективна
• ✅ Null safety позволяет агрессивные оптимизации
• ✅ Специализация типов удаляет overhead

Результат: Flutter приложения работают в 2-3 раза быстрее React Native благодаря мощному Dart VM!