Anthillo /blog
← Wszystkie wpisy

Java kontra C, czyli ile naprawdę kosztuje dekodowanie miliona rekordów

Piotr Osiadacz

Tech Lead / Software Architect ·

Dyskusje o wydajności Javy kontra C zwykle toczą się na benchmarkach z internetu i kończą wnioskiem, który każdy znał przed rozmową. Nam trafił się projekt, w którym musieliśmy rozstrzygnąć to na własnych danych, bo od wyniku zależała architektura systemu. Napisaliśmy ten sam dekoder cztery razy, dwa razy w Javie i dwa razy w C, i zmierzyliśmy wszystko na identycznych plikach. Wyniki były ciekawsze, niż się spodziewaliśmy.

Problem: pliki, które nie mogą czekać

Z rdzenia sieci telekomunikacyjnej cyklicznie spływają binarne rekordy rozliczeniowe. Format jest standardowy dla tej branży: ASN.1 zakodowane regułami BER, do tego opcjonalna kompresja zlib. Pliki mają po sto kilkadziesiąt tysięcy rekordów i kilkadziesiąt megabajtów, a z każdego rekordu trzeba wyciągnąć 21 pól z ponad pięćdziesięciu dostępnych i zapisać je w formie kolumnowej dla hurtowni danych.

Skala na dziś: około 10 milionów rekordów na dobę. Skala z projekcji wzrostu, pod którą system ma być zwymiarowany: ponad 200 milionów na dobę w ciągu kilku lat. Do tego twarde okno czasowe, bo każda paczka plików musi być przetworzona, zanim przyjdzie następna, czyli w kilkanaście minut. I jeszcze jedno wymaganie, o którym łatwo zapomnieć na etapie projektowania: możliwość przeliczenia historii od nowa, kiedy zmieni się zakres pól albo znajdziemy błąd w mapowaniu. Wtedy nie dekodujemy jednej paczki, tylko miesiące danych.

Dekoder to serce tego pipeline’u. Wszystko inne, transport plików, walidacja, ładowanie do hurtowni, jest zwykłą hydrauliką. Dlatego zanim wybraliśmy technologię, postanowiliśmy sprawdzić kilka wariantów naprawdę, a nie na podstawie przeczuć.

Cztery dekodery zamiast jednego

BER to format TLV: tag, długość, wartość, rekurencyjnie w głąb. Do takiego formatu można podejść na dwa sposoby. Albo bierze się bibliotekę ASN.1, która ze specyfikacji generuje lub buduje pełne struktury danych, albo pisze się własny parser, który zna tylko te tagi, które nas interesują, a resztę pomija. Skrzyżowanie tych dwóch podejść z dwoma językami dało nam cztery implementacje:

  1. Java z biblioteką ASN.1, która dekoduje rekordy do wygenerowanych klas, a my tylko przepisujemy pola.
  2. Java z własnym parserem BER, ręczna pętla po tagach, około 2000 linii z testami.
  3. C z kodem wygenerowanym przez kompilator ASN.1 (asn1c), ponad 200 wygenerowanych plików źródłowych plus cienka warstwa mapująca.
  4. C z własnym parserem BER, pisanym od zera pod ten jeden typ rekordu, niecałe 800 linii.

Brzmi jak nadmiar, ale nie był to duży koszt. Formaty TLV parsuje się szybko, a trzy z czterech wariantów powstały w pojedyncze dni robocze. Potraktowaliśmy to jako inwestycję w decyzję, którą potem trzeba będzie utrzymywać latami.

Jak to wygląda w kodzie

Sedno każdego z parserów jest takie samo: pętla czytająca kolejne TLV i dispatch po tagu. W Javie wygląda to tak:

UsageRecordParser.java
BerReader reader = new BerReader(content);
UsageRecordBuilder b = new UsageRecordBuilder();

while (reader.hasMore()) {
    BerTag tag = reader.readTag();
    int length = reader.readLength();
    byte[] value = reader.readValue(length);

    switch (tag.toHexString()) {
        case "83" -> b.subscriberId = FieldDecoders.decodeTbcd(value);
        case "87" -> b.accessPoint = FieldDecoders.decodeIA5String(value);
        case "8D" -> b.openingTime = FieldDecoders.decodeTimestamp(value);
        case "8E" -> b.duration = (int) FieldDecoders.decodeInteger(value);
        case "BF22" -> parseServiceDataList(value, b);
        default -> { } // tagi, których nie potrzebujemy
    }
}
return b.build();

Czytelne, testowalne, przyjemne w utrzymaniu. Ale spójrzmy, co się dzieje w środku readValue():

BerReader.java
public byte[] readValue(int length) {
    byte[] value = new byte[length];   // alokacja na każde pole
    buf.get(value);                    // kopia bajtów z bufora
    return value;
}

Każde pole każdego rekordu to świeża tablica bajtów na stercie plus kopia danych. Do tego obiekt na tag, String na wartość zdekodowaną, obiekt buildera na rekord. Przy dekodowaniu miliona rekordów po dwadzieścia kilka pól robią się z tego dziesiątki milionów krótko żyjących obiektów, które GC musi po nas posprzątać.

Wersja w C robi dokładnie to samo logicznie, ale nie kopiuje ani bajta:

ber_reader.c
int ber_read_tlv(const uint8_t *p, int avail, BerTlv *tlv)
{
    /* ...parsowanie tagu i długości... */

    if (off + tlv->length > avail) return -1;
    tlv->value = p + off;              /* wskaźnik w bufor wejściowy, zero kopii */
    tlv->total_bytes = off + tlv->length;
    return tlv->total_bytes;
}

Wartość TLV to wskaźnik w zmapowany bufor pliku. Struktura rekordu żyje na stosie i jest nadpisywana w miejscu przy każdym kolejnym rekordzie. Przez cały czas dekodowania pliku nie ma ani jednego malloc. Dekodery pól piszą prosto do buforów wynikowych:

cdr_fields.c
char *decode_tbcd(const uint8_t *data, int len, char *buf)
{
    char *p = buf;
    for (int i = 0; i < len; i++) {
        int lo = data[i] & 0x0F;
        int hi = (data[i] >> 4) & 0x0F;
        if (lo < 10) *p++ = '0' + lo; else if (lo == 0xF) break;
        if (hi < 10) *p++ = '0' + hi; else if (hi == 0xF) break;
    }
    *p = '\0';
    return buf;
}

Ten sam dekoder w Javie to StringBuilder i String na wyjściu. Pojedynczo to nic, pomnożone przez setki milionów wywołań robi różnicę, którą zaraz zobaczycie w tabeli.

Wyniki

Benchmark: 250 tysięcy rekordów w plikach o łącznym rozmiarze 48 MB, bez kompresji, jeden wątek. Środowisko celowo skromne, zwykła wirtualka z naszego wewnętrznego zaplecza testowego: 4 vCPU na współdzielonych rdzeniach, 8 GB RAM, Ubuntu, ext4. Żadnego egzotycznego żelaza i to jest ważny kontekst dla liczb poniżej, bo wszystko, co widać w tabeli, każda maszyna produkcyjna z dedykowanymi rdzeniami może tylko poprawić. Każdy dekoder dostał identyczne dane i wynik uśredniliśmy z wielu przebiegów, po rozgrzaniu JVM tam, gdzie to dotyczy.

DekoderCzasRekordy/sWzględem najszybszego
C, własny parser BER0,23 s~1 090 0001,0×
Java, biblioteka ASN.11,45 s~172 0006,3× wolniej
C, kod generowany z ASN.15,6 s~45 00024× wolniej
Java, własny parser BER10,9 s~23 00047× wolniej

Dwie rzeczy z tej tabeli są ważniejsze niż sam ranking.

Po pierwsze, rozstrzał wewnątrz jednego języka był większy niż między językami. Dwa programy w C dzieli różnica 24×. Dwie Javy dzieli 7×. Gdyby ktoś porównał tylko wariant drugi z trzecim, wyszłoby mu, że Java jest kilkukrotnie szybsza od C, i w ramach tego zestawienia miałby rację.

Po drugie, najlepsza Java pobiła C z wygenerowaną biblioteką czterokrotnie. Kod generowany przez asn1c jest poprawny i kompletny, ale płaci za ogólność: alokuje i zwalnia pełne drzewo struktur na każdy rekord, także dla pól, których nikt nie czyta. JIT w JVM z dobrą biblioteką strumieniową miał tu łatwiejsze zadanie niż malloc i free wywoływane miliony razy.

Stawkę zamknął wariant z własnym parserem w Javie i to akurat nie było zaskoczenie, bo świadomie napisaliśmy go czytelnością do przodu: niemutowalne obiekty, kopie buforów, builder na rekord. Dokładnie tak, jak wygląda dobry kod aplikacyjny w Javie. Ten wynik nie mówi więc, że ktoś napisał go słabo. Mówi, ile w tym konkretnym zadaniu kosztuje styl, który na co dzień słusznie wybieramy dla utrzymywalności. Dałoby się ten wariant mocno przyspieszyć, przechodząc na widoki ByteBuffer bez kopii i obiekty wielokrotnego użytku, tylko że wtedy pisalibyśmy C w składni Javy i stracilibyśmy czytelność, dzięki której ten kod i tak został z nami na dłużej, o czym za chwilę.

Obserwacja. O wydajności nie zdecydował język, tylko model pracy z pamięcią. Zwycięski wariant wygrał nie dlatego, że był w C, ale dlatego, że nie alokował nic. Język był narzędziem, które na to pozwoliło bez walki z własnymi idiomami.

Co poszło na produkcję

Na produkcję trafił własny parser w C, opakowany w proste CLI: pliki na wejściu, kolumnowy tekst na wyjściu, wołany przez pipeline jako osobny proces. Po rozszerzeniu z okrojonego zestawu pól do pełnego formatu przepustowość spadła do około 420 tysięcy rekordów na sekundę na wątek, wciąż na tej samej wirtualce 4 vCPU, co przy naszych wolumenach oznacza:

  • bieżąca paczka plików: ułamek sekundy, przy oknie liczonym w minutach,
  • cała doba danych: niecałe pół minuty na jednym wątku,
  • przeliczenie miesiąca historii przy zmianie schematu: kilkanaście minut zamiast nocnego okna serwisowego.

W praktyce dekodowanie przestało istnieć jako pozycja w budżecie czasowym systemu. Zapas względem projekcji wzrostu jest na tyle duży, że skalowanie sprowadza się do odkręcenia liczby równoległych procesów, gdyby kiedyś było potrzebne.

Czy Java by tego nie udźwignęła? Dziś by udźwignęła. Najszybszy wariant Javy przetworzyłby bieżącą dobę w kilka minut i zmieściłby się w oknie. Decyzję przesądziły projekcje, pełny format i scenariusz przeliczania historii, przy których zapas topniał z lat do godzin. Woleliśmy rozstrzygnąć to raz, na etapie, na którym zmiana kosztowała jeden plik Makefile, a nie migrację działającego systemu.

Utrzymanie, czyli druga strona medalu

C na produkcji brzmi jak przepis na kłopoty i traktowaliśmy to ryzyko poważnie, bo błąd wskaźnika w parserze danych wejściowych to klasyka podatności. Kilka rzeczy sprawiło, że po roku eksploatacji nadal śpimy dobrze.

Mały, nudny kod. Cały parser to niecałe 800 linii C bez jednej alokacji i z jedną zależnością, systemowym zlib. Da się go przeczytać w całości w jedno popołudnie, co czyni go realnie audytowalnym. Build debugowy kompiluje się z AddressSanitizerem i UBSanem, a testy przepuszczają przez niego także dane uszkodzone i ucięte w losowych miejscach.

Java nie wyleciała z projektu. Została tam, gdzie jest najlepsza. Nasz javowy moduł generuje syntetyczne pliki testowe w formacie binarnie zgodnym z produkcyjnym, ma ponad sto testów z pełnym round-tripem zakodowania i odkodowania, i służy jako implementacja referencyjna. Test porównawczy dekoduje te same pliki Javą i C, po czym porównuje wyniki pole po polu. Każda zmiana w parserze C musi przejść przez tę bramkę. To zdjęło z C największy ciężar utrzymaniowy: nie musimy ufać, że jest poprawny, bo sprawdzamy to automatycznie przy każdej zmianie.

Granica odpowiedzialności jest wąska. C robi jedną rzecz: czyta bajty, pisze tekst. Cała logika biznesowa, orkiestracja, obsługa błędów pipeline’u żyje poza nim, w technologiach, w których zmiany są tanie. Gdyby format źródłowy zmieniał się często, ten rachunek wyglądałby inaczej, bo dopisanie pola do ręcznego parsera to ręczna robota przy dispatchu tagów, a biblioteka ASN.1 dostałaby je z regeneracji schematu. U nas format zmienia się rzadko i to przesądziło sprawę.

Wnioski

Nie ma jednej odpowiedzi na pytanie, czy Java jest wolniejsza od C. Najszybsza Java z tego porównania była czterokrotnie szybsza od wolniejszego C. Jest za to odpowiedź na pytanie, co zrobić, gdy wydajność naprawdę ma znaczenie: zmierzyć na własnych danych, na kilku wariantach, zanim architektura zabetonuje wybór. A jeśli wynik pcha w stronę C, zawęzić mu odpowiedzialność do minimum i zostawić sobie wygodną implementację referencyjną w języku, w którym testy pisze się przyjemnie. U nas ten podział, C dekoduje, Java pilnuje poprawności, okazał się trwalszy niż jakikolwiek pojedynczy benchmark.

← Wszystkie wpisy