Domain-Driven Type Safety va Performance: Project Valhalla Nima O'zgartiradi

Java’da domain-driven arxitektura qurgan bo’lsangiz, bu muammoni bilasiz. PositiveInt kabi maxsus tur yaratmoqchisiz – u hech qachon manfiy bo’lmaydi. Kompilyator noto’g’ri qiymatlarni rad etsin. Xavfsizlik kerak.

Lekin hot pathda muammo chiqadi. Millionlab voqealarni qayta ishlaydigan processor, har birida PositiveInt sequence raqami bor. Endi bu xavfsiz wrapper ob’ektlari muammo bo’lib qoladi – har bir qiymat uchun 16 bayt ortiqcha xarajat, millionlab heap allocation, cache-line muammolari. Yillar davomida ishlatilgan qoida: type’larni chegarada aniqlang, keyin performance muhim joylarda ulardan voz keching.

Project Valhalla bu qoidani o’zgartirmoqchi.

Eski Muammo: Wrapper Xarajati

Oddiy misol bilan tushuntiraylik. PositiveInt wrapper klassi bitta int saqlaydi va HotSpot’da 16 bayt oladi – 12 bayt ob’ekt header va 4 bayt qiymat. Millionta shunday ob’ektni array’ga joylashtirsangiz, array faqat reference’larni saqlaydi, qiymatlarni emas. Har bir reference pointer dereference, ehtimoliy cache miss.

Hisob oddiy: wrapper o’zini himoya qilayotgan primitive’dan 4 baravar ko’p xotira oladi. Tasodifiy kirish pattern’larida muammo yanada yomonlashadi – har bir kirish boshqa joydagi pointer’ni kuzatishni talab qiladi, bu esa CPU cache’dan foydali ma’lumotlarni siqib chiqaradi.

Bu og’ir arxitektura cheklovini yaratdi. Domain primitive’lar API chegaralarida yaxshi ishlaydi – u yerda input validation va invariant’lar o’rnatiladi. Lekin ma’lumotlar hot loop orqali o’tayotganda – stream’lar qayta ishlanayotgan, collections transformatsiya qilinayotgan, numerical algorithm’lar ishlayotgan – siz primitiv int yoki long ga cast qilishingiz kerak edi, shu bilan type safety yo’qoldi.

Muammo real edi. Yechim to’liq emas edi.

Value Classes: Type Safety va Kam Xarajat

Project Valhalla, Java 27 Early Access’da mavjud, value keyword’ini kiritadi. M regular classes (ularda identity bor va heap allocation talab qiladi) dan farqli ravishda, value classes identity-free. JVM ularni primitives kabi davolaydi – ularni har qanday joyda flatten qilishi mumkin: array’lari inline, ob’ekt field’lariga embedded, CPU register’lariga packed.

Bu qanday ko’rinadi:

public value class PositiveInt {
    private final int value;

    public PositiveInt(int value) {
        if (value <= 0) {
            throw new IllegalArgumentException("must be positive: " + value);
        }
        this.value = value;
    }

    public int value() { 
        return value; 
    }
}

Syntax oddiy class’ga yaqin. Constructor hali ham run qiladi. Validation hali ham qiladi. Static guarantee qoladi: har qanday joyda PositiveInt ko’rsangiz, qiymat positive bo’ladi.

Tushuntiraylik: JVM bu 4 bayt int qiymatni array slot’ga, ob’ekt field’ga yoki register’ga inlined qilishiga q Frei. Ob’ekt header yo’q. Indirection yo’q. Cache miss yo’q.

Multi-F