Вступ до Project Panama. Частина 4. Як керувати off-heap пам’яттю

💡 Усі статті, обговорення, новини про Java — в одному місці. Приєднуйтесь до Java спільноти!

Частина 1 | Частина 2 | Частина 3

Важливою частино роботи із нативним кодом є керування пам’яттю. Мова С дає одразу і найпотужніший, і найнебезпечніший інструмент роботи з пам’яттю — C malloc (та С free). Специфіка така, що необачне керування пам’яттю може призвести до позаштатного завершення роботи застосунку. Проблема стає більш масштабною та ще ризикованішою, коли мова йде про роботу з нативною (off-heap) пам’яттю засобами JDK для успішного виконання нативних функцій.

Керування пам’яттю

Факт № 1: JVM за замовчанням керує лише heap-ом.

Факт № 2: Project Panama дозволяє керувати усією наявною пам’яттю для застосунків.

Foreign Function & Memory API надає два класи для керування пам’яттю: MemorySession, SegmentAllocator.

MemorySession

С malloc виконує функцію аллокації сегментів пам’яті, як антипод до неї існує функція free, як видаляє сегмент пам’яті за фактичним посиланням на неї:

#include <stdlib.h>

#include <stdio.h>

int main() {

    int len = 10;

    char * buffer = (char*) malloc(len + 1);

    for (int ix = 0; ix < len; ix++)

        buffer[ix] = rand() % 26 + 'a';

    buffer[len]='\0';

    puts(buffer);

    free(buffer);

    return 0;

}

У такому додатку майже немає жодних проблем з тим, щоб уникнути виклик free, але якщо мова йде про додатки, які працюють у режимі демонів, то постає проблема з тим, що «десь» тече пам’ять. Тому, скажімо так, існує важливе правило: free ЗАВЖДИ має слідувати за malloc!

Якщо уявити, що ми можемо створити Java варіат до malloc, то буде дуже розумно загорнути його у AutoCloseable. Як Java-розробники, ви, певно, знайомі з цим інтерфейсом. Він допомагає «автоматично» викликати метод close при виході за межі блоку try-with-resources. Розробники Project Panama попіклувалися про нас, розробників, й впровадили API для керування пам’яттю — MemorySession.

MemorySession — це механізм доступу до off-heap пам’яті, який дозволяє виділяти та повертати сегменти пам’яті до операційної системи. Ну, і для комфорту використання цей механізм розширяє інтерфейс AutoCloseable:

try(var ms = MemorySession.openConfined()) {

     …

}

Коли мова йде про C malloc, то виділення пам’яті стосується суто велечин нативних типів або їх комбінацій (масиви, структури). У Java ж ситуація інша — необхідно вміти виділяти нативну пам’ять під Java об’єкти, які мають відповідний нативний тип, якщо коротко, то мова йде про усі примітивні типи, значення котрих вміщюється в long або є композитним типом (масив, структура, юніон).

Основним функціоналом MemorySession є виділення пам’яті, тому вкрай важливим функціоналом є наступні методи:

try(var ms = MemorySession.openConfined()) {

    var forBoolean = ms.allocate(1);

    var forIntAligned = ms.allocate(4, 8);

    var forPTR = ms.allocate(ValueLayout.ADDRESS);

}

Тобто, з трьома основними функціями:

• Виділення N байтів
• Виділення N байтів з вирівнюванням
• Виділення N байтів згідно з макетом типу

MemoryLayout

JVM нічого не знає про нативні С типи. Єдине, що вона може — оперувати сегментами байтів (CRUD). Питання полягає у тому, як створити такий сегмент пам’яті, який би відповідав примітивним типам Java? Відповіддю на це питання як раз і є MemoryLayout, а також розширення цього класу ValueLayout, GroupLayout, SequenceLayout, PaddingLayout.

ValueLayout

У JDK ValueLayout є вдосталь імплементацій макетів типів, щоб покрити усі примітиви Java:

• ValueLayout.OfAddress Address
• ValueLayout.OfBoolean JAVA_BOOLEAN
• ValueLayout.OfByte JAVA_BYTE
• ValueLayout.OfChar JAVA_CHAR
• ValueLayout.OfShort JAVA_SHORT
• ValueLayout.OfDouble JAVA_DOUBLE
• ValueLayout.OfFloat JAVA_FLOAT
• ValueLayout.OfInt JAVA_INT
• ValueLayout.OfLong JAVA_LONG

Як зазначено вище, за допомогою макетів можно виділяти відповідний сегмент (масив байтів), у який можна записати відповідне значення типу Java, наприклад:

try(var ms = MemorySession.openConfined()) {

    var jChar = ms.allocate(JAVA_CHAR); // 2 bytes

    var jShort = ms.allocate(JAVA_SHORT); // 2 bytes

}

Як бачите, за допомогою цих макетів ми виділяємо пам’ять під змінні, типи яких належать Java, але мають відображення у С типах. Це значить, що неможливо зробити це, наприклад, для класу або рекорду, навіть якщо можна порахувати, скільки байт займає клас із усіма полями.

GroupLayout

Інша ж справа, якщо мати відображення Java класу на С структуру, але для того, щоб мати змогу створювати сегменти пам’яті під структури, необхідно пояснити і відповідним чином описати структуру, як послідовність змінних з відповідними макетами типів. Іншими словами — визначити тип структури за допомогою StructLayout.

Розглянемо наступний приклад:

struct A {

    int a;

    short b;

    char c;

    short d;

};

Еквівалент типу С struct A буде відповідний Java макет:

var structLayout = MemoryLayout.structLayout(

        JAVA_INT.withName("a").withBitAlignment(32),

        JAVA_SHORT.withName("b").withBitAlignment(16),

        JAVA_BYTE.withName("c").withBitAlignment(8),

        MemoryLayout.paddingLayout(8),

        JAVA_SHORT.withName("d").withBitAlignment(16),

        MemoryLayout.paddingLayout(24)

).withName("A");

Застосування паддінгу тут не є доцільним, але є дуже позаковим, бо struct A в С займає як раз 12 байт, бо пам’ять розмічена по DWORD (4 байти).

Використовуючи цей макет структури, можна виділити пам’ять під довільний екземпляр:

try(var ms = MemorySession.openConfined()) {

    var jStruct = ms.allocate(structLayout); // 12 bytes

}

SequenceLayout

Для того, щоб виділити пам’ять під примітив, треба лише вказати макет типу:

try(var ms = MemorySession.openConfined()) {

    var jArray = ms.allocateArray(JAVA_INT, 5); // int[5], 20 bytes

}

Така ж процедура стосується й масивів композитних типів, скажімо, struct A[5]. Тут можна застосувати два підходи:

try(var ms = MemorySession.openConfined()) {

    var jArray = ms.allocateArray(structLayout, 5); // A[5], 60 bytes

}

або

var sequenceLayout = MemoryLayout.sequenceLayout(5, structLayout).withName("B");

try(var ms = MemorySession.openConfined()) {

    var jArray = ms.allocate(sequenceLayout, 5); // A[5], 60 bytes

}

UnionLayout та PaddingLayout я залишу вас на подивится.

Робота з сегментами пам’яті

Взагалі, макети існують для того, щоб якісно описувати структуру сегменту пам’яті, виділеної під змінну, типу якої відповідає макет. Розглянемо наступний приклад:

int a = 100;

try(var ms = MemorySession.openConfined()) {

    var jInt = ms.allocate(JAVA_INT);

    jInt.set(JAVA_INT, 0, a);

    var b = jInt.get(JAVA_INT, 0);

    assert a == b;

}

Цей код означає, що у сегмент пам’яті розміром 4 байти з нульової позиції ми записуємо значення int a = 100.

Розглянемо складніший і детальніший приклад — перетворення String на char*. Враховуючи те, що C не має гадки про Java String, необхідно перетворити на той тип даних який буде зрозумілий, а саме на char[] :

var str = “Hello World!”;

var bytes = str.getBytes(StandardCharsets.UTF_8);

try(var ms = MemorySession.openConfined()) {

    var ms = ms.allocate(bytes.length + 1);

    var bytes$ms = MemorySegment.ofArray(bytes);

    ms.copyFrom(bytes$ms);

    ms.set(JAVA_BYTE, bytes.length, (byte)0);

}

Отже, необхідно створити масив, розмір якого буде відповідати довжині строки з додатком у вигляді одного байта для нуль-термінатора.

Як ви можете побачити, функціонал MemorySession має можливості роботи з пам’яттю, розмір якої обмежений лише тим, що є у наявності в опертивній системі. Недоліком є те, що об’єм наявної пам’яті може змінюватися, що потенційно може призвести до банальної нестачі пам’яті (OutOfMemory).

SegmentAllocator

У той час, як MemorySession працює з тим залишком пам’яті, який їй доступний, SegmentAllocator працює дещо інакше, бо передбачає створення великих сегментів пам’яті одночасно, такі сегменти ще називаються «арени». Загалом SegmentAllocator використовується у тих випадках, коли треба зарезерувати сегмент необхідного розміру під певну задачу, і вже у межах неї займатися виділенням пам’яті сегментами необхідної довжини:

var one = "My name is %s.\n";

var two = "Denis";

var three = "I'm %dyo old.\n";

var four = 31;

var five = one + three;

try(var ms = MemorySession.openConfined()) {

    var sa = SegmentAllocator.newNativeArena(

            one.length() + 1 + two.length() + 1 +

            three.length() + 1 + five.length() + 1,

           ms

    );

    var one$sa = sa.allocateUtf8String(one);

    var two$sa = sa.allocateUtf8String(two);

    var three$sa = sa.allocateUtf8String(three);

    var five$sa = sa.allocateUtf8String(five);

    stdio_h.printf(one$sa.address(), two$sa.address());

    stdio_h.printf(three$sa.address(), four);

    stdio_h.printf(five$sa.address(), two$sa.address(), four);

}

Термін «арена» походить з C++ і фактично означає ізольований, великий сегмент пам’яті. Розподіл off-heap пам’яті на арени був розроблений, щоб зменшити витрати на процедуру виділення пам’яті посегментно. Усі ці сегменти пам’яті у межах арени можна звільнити одразу одночасно, виконавши рекламацію усієї арени цілком, в ідеалі без запуску деструкторів об’єктів відображених на арені. Це робить розподіл об’єктів швидшим, зводячи його до простого інкріменту покажчика на точку розподілу зайнятої та вільної пам’яті, що робить звільнення усіє арени одночасно майже безкоштовним.

Дивлячись на цей приклад не можна однозначно сказати, що станеться з ареною після того, як SegmentAllocator стане непотрібним. А магія JVM криється як раз «під капотом», при видаленні аллокатора у циклі GC уся пам’ять, що виділена ним, повернеться операційній системі. Треба зазначити, що те ж саме станеться з MemorySession, але різниця полягає у тому, що арену можна звільнити за один раунд, а от звільнення пам’яті, виділеної MemorySession буде повільнішим, бо «рекламація» буде проходити посегментно.

На що треба звернути увагу в роботі з аренами:

1. Арена обмежена у розмірі від самого початку.
2. Виділення пам’яті у межах арени робиться за допомогою SegmentAllocator, а не MemorySession.
3. SegmentAllocator не має методу close, отже арену не треба ані закривати, ані видаляти явним чином.
4. Виділення сегменту, розмір якого не вписується в арену (нестача пам’яті, завеликий сегмент) призведе до помилки OutOfMemory.

Якщо подивитися у реалізацю, то буде зрозуміло, що MemorySession та SegmentAllocator пов’язані між собою — MemorySession розширює функціонал SegmentAllocator, але працює як SegmentAllocator, чия арена налічує усю наявну пам’ять. Враховуючи цей факт, можна зробити висновок, що загальним рішенням для роботи з пам’яттю буде MemorySession, а SegmentAllocator — для специфічних задач.

P.S.

Пам’ятайте про те, що Foreign Function & Memory API доступно у режимі Preview. Щоб працювати з цим API, треба:

• Скомпілюйте програму за допомогою javac --release 19 --enable-preview Main.java та запустіть її за допомогою java --enable-preview Main.
• Використовуючи програму запуску вихідного коду, запустіть програму з java --source 19 --enable-preview Main.java.
• Використовуючи jshell, почніть його з jshell --enable-preview.

----

dev.java | inside.java | Java on YouTube | Java on Twitter | Me on Twitter