Skjulte feller i arithmetic coding: Hvorfor komprimeringen din kaster bort bits

Arithmetic coding virker smart og elegant. Den mapper bitsekvenser til nøyaktige sannsynlighetsintervaller. Men de fleste enkle implementasjoner du finner på nett, underpresterer – uten at du merker det.

Jeg snakker ikke bare om hastighet. Det handler om komprimeringsgraden. Det er jo poenget med entropy coding.

Den klassiske versjonen som svikter

Typiske eksempler ser slik ut:

let mut left: u32 = 0;
let mut right: u32 = u32::MAX;

fn encode_bit(bit: bool, probability: f32) {
    let mid = left + ((right - left) as f32 * probability) as u32;
    if !bit {
        right = mid;
    } else {
        left = mid + 1;
    }
    
    while left >> 24 == right >> 24 {
        output_byte((left >> 24) as u8);
        left <<= 8;
        right = (right << 8) | 0xff;
    }
}

Du holder et intervall [left, right]. Hver bit krymper det basert på sannsynlighet. Når øverste byte er kjent, spytter du ut den.

Problemet? Implementasjonen har en skjevhet som ikke finnes i den teoretiske modellen.

Byte-grensens triks

I den perfekte versjonen oppfører alle intervaller seg likt, uansett lengde. Med 32-bit heltall skjer det ikke.

Ta to tilfeller:

1. Intervall fra left = 0 krymper aldri under 2^24 bits.
2. Intervall nær left = 2^31 - 1 kan bli nede i 2 bits.

Årsaken ligger i betingelsen left >> 24 == right >> 24. Den avhenger av intervallposisjonen, ikke bare størrelsen.

Når intervall krysser byte-grense, som [2^31 - 1, 2^31], blir det fort trangt. Sannsynligheter kvantiseres grovt. En bit med 0.95 sannsynlighet kan ende som 50/50-split. Resultatet? Mer output enn nødvendig.

Dekoderens hemmelige belastning

Dekoderen har lignende problemer:

fn decode_bit(probability: f32) -> bool {
    let mid = left + ((right - left) as f32 * probability) as u32;
    if x <= mid {
        right = mid;
        bit = false;
    } else {
        left = mid + 1;
        bit = true;
    }
    
    while left >> 24 == right >> 24 {
        left <<= 8;
        right = (right << 8) | 0xff;
        x = (x << 8) | (bytes.next().unwrap() as u32);
    }
    
    bit
}

Den sporer left, right og x. Matematisk trenger du bare intervalllengde (right - left) og posisjon (x - left).

Årsaken er while-løkken som krever absolutt posisjon. Dette gir:

• Mer registerbruk
• Svakere optimaliseringer
• Kode som er vanskelig å følge

Løsningen

Bytt ut byte-dumping basert på posisjon. Bruk i stedet intervalllengde alene. Da blir alt uavhengig av offset.

Det krever omarbeiding av hele løkken. Men gevinsten? Bedre komprimering, enklere og raskere dekoder.

Hvorfor det teller for NameOcean

Hos NameOcean hjelper vi utviklere med alt fra AI-apper på Vibe Hosting til optimaliserte systemer. Komprimering er kritisk for cloud-lagring, API-trafikk eller store datasett.

Mange bruker biblioteker uten å kjenne svakhetene. 5-10% bedre ratio blir stort på petabyte-skala eller millioner av requests.

Lærdommen: "Standard"-kode har ofte skjulte feil. Grav dypere. Still spørsmål ved antakelsene. Gode ingeniører kjenner edge cases.

Bygger du ytelseskritiske apper i skyen? Små algoritmeendringer gir stor effekt over millioner av kall. Detaljene avgjør. Sjekk stacken din hos NameOcean.