Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-compress

Source of release 0.9.1

0.9.1 / tests / bench / deflate_bench.lucb

## Deflate throughput, one thread: `deflate_bench <kind> <levels...> [--write <path>]`.
## `kind` is `photo` (a 6000x4000 RGBA8 gradient with noise 0..15, as a PNG's
## Sub-filtered rows: 96 MB) or `flat` (the same size of flat-colored art with
## hard edges), or a path to a file of bytes. Each level deflates the data in
## independent 1 MiB segments, as luce-png's bands do, and prints MB/s and the
## compressed size. `--write` saves the generated data for other tools.
import c
from luce_std import files
import memory
import strings
import time
import flate

let width: usize = 6000
let height: usize = 4000
let segment: usize = 1048576

## Rows of `width` RGBA8 pixels, each led by PNG's Sub filter byte.
func generate(kind: str) -> u8[]!:
    let stride = width * 4 + 1
    let data = try new u8[stride * height] --- in memory.heap
    var seed: u32 = 2463534242
    for y in 0..<height:
        let row = y * stride
        data[row] = 1
        var previous: u8[4] = [0, 0, 0, 0]
        for x in 0..<width:
            var pixel: u8[4] = [0, 0, 0, 255]
            if kind == "photo":
                seed ^= seed << 13
                seed ^= seed >> 17
                seed ^= seed << 5
                let noise = seed & 15
                pixel[0] = (u8)((x * 200 // width + noise) & 255)
                pixel[1] = (u8)((y * 200 // height + (noise >> 1)) & 255)
                pixel[2] = (u8)(((x + y) * 100 // (width + height) + (noise >> 2)) & 255)
            else:
                # Flat art: bands and blocks of solid color with hard edges.
                let block = (x // 373 + y // 211 * 3) % 7
                pixel[0] = (u8)(block * 36)
                pixel[1] = (u8)(255 - block * 30)
                pixel[2] = (u8)((block * 91) & 255)
                if (x // 50 + y // 50) % 11 == 0:
                    pixel[3] = 0
            for channel in 0..<(usize)4:
                data[row + 1 + x * 4 + channel] = pixel[channel] -% previous[channel]
                previous[channel] = pixel[channel]
    return data

pub func main(arguments: str[]) -> i32!:
    if arguments.length < 3:
        print("usage: deflate_bench <photo|flat|path> <levels...> [--write <path>]")
        return 2
    let kind = arguments[1]
    var data: const u8[]
    if kind == "photo" or kind == "flat":
        data = try generate(kind)
    else:
        data = (try files.read((c.str)kind)).value
    let out = try new u8[flate.deflate_bound(segment) + 64] --- in memory.heap
    var index: usize = 2
    while index < arguments.length:
        if arguments[index] == "--write":
            try files.write((c.str)arguments[index + 1], data)
            index += 2
            continue
        let level = (i32)(strings.parse_u64(arguments[index]) else 6)
        var best: u64 = 0
        var total: usize = 0
        for round in 0..<(usize)2:
            let start = time.now()
            var size: usize = 0
            var at: usize = 0
            while at < data.length:
                let end = at + segment if at + segment < data.length else data.length
                size += try flate.deflate_raw(data[at..<end], level, out, end == data.length)
                at = end
            let spent = time.since(start)
            if round == 0 or spent < best:
                best = spent
            total = size
        let mb = (f64)data.length / 1000000.0
        let seconds = (f64)best / 1000000000.0
        print(f"level {level}: {(i64)(mb / seconds)} MB/s, {best // 1000000} ms, {total} bytes ({(i64)((f64)total * 1000.0 / (f64)data.length) } per mille)")
        index += 1
    return 0