benchmarking

use criterion::*;

const T: [u8; 64] = [
    b'A', b'B', b'C', b'D', b'E', b'F', b'G', b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O', b'P',
    b'Q', b'R', b'S', b'T', b'U', b'V', b'W', b'X', b'Y', b'Z', b'a', b'b', b'c', b'd', b'e', b'f',
    b'g', b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o', b'p', b'q', b'r', b's', b't', b'u', b'v',
    b'w', b'x', b'y', b'z', b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'+', b'/',
];

fn b64_encode1a(xs: &[u8]) -> Vec<u8> {
    let mut ix = 0;
    let mut out = vec![0; (xs.len() + 2) / 3 * 4];
    for ys in xs.chunks_exact(3) {
        out[ix] = T[(ys[0] >> 2 & 0x3f) as usize];
        out[ix + 1] = T[(ys[0] << 4 & 0x30 | ys[1] >> 4 & 0x0f) as usize];
        out[ix + 2] = T[(ys[1] << 2 & 0x3c | ys[2] >> 6 & 0x03) as usize];
        out[ix + 3] = T[(ys[2] & 0x3f) as usize];
        ix += 4;
    }
    out
}

fn b64_encode1b(xs: &[u8]) -> Vec<u8> {
    let mut ix = 0;
    let mut out = vec![0; (xs.len() + 2) / 3 * 4];
    let mut it6 = xs.chunks_exact(6);
    for ys in &mut it6 {
        out[ix] = T[(ys[0] >> 2 & 0x3f) as usize];
        out[ix + 1] = T[(ys[0] << 4 & 0x30 | ys[1] >> 4 & 0x0f) as usize];
        out[ix + 2] = T[(ys[1] << 2 & 0x3c | ys[2] >> 6 & 0x03) as usize];
        out[ix + 3] = T[(ys[2] & 0x3f) as usize];
        out[ix + 4] = T[(ys[3] >> 2 & 0x3f) as usize];
        out[ix + 5] = T[(ys[3] << 4 & 0x30 | ys[4] >> 4 & 0x0f) as usize];
        out[ix + 6] = T[(ys[4] << 2 & 0x3c | ys[5] >> 6 & 0x03) as usize];
        out[ix + 7] = T[(ys[5] & 0x3f) as usize];
        ix += 8;
    }
    for ys in it6.remainder().chunks_exact(3) {
        out[ix] = T[(ys[0] >> 2 & 0x3f) as usize];
        out[ix + 1] = T[(ys[0] << 4 & 0x30 | ys[1] >> 4 & 0x0f) as usize];
        out[ix + 2] = T[(ys[1] << 2 & 0x3c | ys[2] >> 6 & 0x03) as usize];
        out[ix + 3] = T[(ys[2] & 0x3f) as usize];
        ix += 4;
    }
    out
}

fn b64_encode1c(xs: &[u8]) -> Vec<u8> {
    let mut ix = 0;
    let mut out = vec![0; (xs.len() + 2) / 3 * 4];
    let mut it12 = xs.chunks_exact(12);
    for ys in &mut it12 {
        out[ix] = T[(ys[0] >> 2 & 0x3f) as usize];
        out[ix + 1] = T[(ys[0] << 4 & 0x30 | ys[1] >> 4 & 0x0f) as usize];
        out[ix + 2] = T[(ys[1] << 2 & 0x3c | ys[2] >> 6 & 0x03) as usize];
        out[ix + 3] = T[(ys[2] & 0x3f) as usize];
        out[ix + 4] = T[(ys[3] >> 2 & 0x3f) as usize];
        out[ix + 5] = T[(ys[3] << 4 & 0x30 | ys[4] >> 4 & 0x0f) as usize];
        out[ix + 6] = T[(ys[4] << 2 & 0x3c | ys[5] >> 6 & 0x03) as usize];
        out[ix + 7] = T[(ys[5] & 0x3f) as usize];
        out[ix + 8] = T[(ys[6] >> 2 & 0x3f) as usize];
        out[ix + 9] = T[(ys[6] << 4 & 0x30 | ys[7] >> 4 & 0x0f) as usize];
        out[ix + 10] = T[(ys[7] << 2 & 0x3c | ys[8] >> 6 & 0x03) as usize];
        out[ix + 11] = T[(ys[8] & 0x3f) as usize];
        out[ix + 12] = T[(ys[9] >> 2 & 0x3f) as usize];
        out[ix + 13] = T[(ys[9] << 4 & 0x30 | ys[10] >> 4 & 0x0f) as usize];
        out[ix + 14] = T[(ys[10] << 2 & 0x3c | ys[11] >> 6 & 0x03) as usize];
        out[ix + 15] = T[(ys[11] & 0x3f) as usize];
        ix += 16;
    }
    for ys in it12.remainder().chunks_exact(3) {
        out[ix] = T[(ys[0] >> 2 & 0x3f) as usize];
        out[ix + 1] = T[(ys[0] << 4 & 0x30 | ys[1] >> 4 & 0x0f) as usize];
        out[ix + 2] = T[(ys[1] << 2 & 0x3c | ys[2] >> 6 & 0x03) as usize];
        out[ix + 3] = T[(ys[2] & 0x3f) as usize];
        ix += 4;
    }
    out
}

fn b64_encode2a(xs: &[u8]) -> Vec<u8> {
    let mut ix = 0;
    let mut out = vec![0; (xs.len() + 2) / 3 * 4];
    for jx in (0..xs.len() / 3 * 3).step_by(3) {
        out[ix] = T[(xs[jx] >> 2 & 0x3f) as usize];
        out[ix + 1] = T[(xs[jx] << 4 & 0x30 | xs[jx + 1] >> 4 & 0x0f) as usize];
        out[ix + 2] = T[(xs[jx + 1] << 2 & 0x3c | xs[jx + 2] >> 6 & 0x03) as usize];
        out[ix + 3] = T[(xs[jx + 2] & 0x3f) as usize];
        ix += 4;
    }
    out
}

fn b64_encode2b(xs: &[u8]) -> Vec<u8> {
    let mut ix = 0;
    let mut out = vec![0; (xs.len() + 2) / 3 * 4];

    for jx in (0..xs.len() / 6 * 6).step_by(6) {
        out[ix] = T[(xs[jx] >> 2 & 0x3f) as usize];
        out[ix + 1] = T[(xs[jx] << 4 & 0x30 | xs[jx + 1] >> 4 & 0x0f) as usize];
        out[ix + 2] = T[(xs[jx + 1] << 2 & 0x3c | xs[jx + 2] >> 6 & 0x03) as usize];
        out[ix + 3] = T[(xs[jx + 2] & 0x3f) as usize];
        out[ix + 4] = T[(xs[jx + 3] >> 2 & 0x3f) as usize];
        out[ix + 5] = T[(xs[jx + 3] << 4 & 0x30 | xs[jx + 4] >> 4 & 0x0f) as usize];
        out[ix + 6] = T[(xs[jx + 4] << 2 & 0x3c | xs[jx + 5] >> 6 & 0x03) as usize];
        out[ix + 7] = T[(xs[jx + 5] & 0x3f) as usize];
        ix += 8;
    }

    for jx in (xs.len() / 6 * 6..xs.len() / 3 * 3).step_by(3) {
        out[ix] = T[(xs[jx] >> 2 & 0x3f) as usize];
        out[ix + 1] = T[(xs[jx] << 4 & 0x30 | xs[jx + 1] >> 4 & 0x0f) as usize];
        out[ix + 2] = T[(xs[jx + 1] << 2 & 0x3c | xs[jx + 2] >> 6 & 0x03) as usize];
        out[ix + 3] = T[(xs[jx + 2] & 0x3f) as usize];
        ix += 4;
    }
    out
}

fn bench(c: &mut Criterion) {
    let v = (0..128 * 1024).map(|x| x as u8).collect::<Vec<u8>>();

    let mut group = c.benchmark_group("b64");
    group.throughput(Throughput::Bytes(v.len() as u64));
    group.bench_function("b64_encode1a", |b| b.iter(|| b64_encode1a(&v)));
    group.bench_function("b64_encode1b", |b| b.iter(|| b64_encode1b(&v)));
    group.bench_function("b64_encode1c", |b| b.iter(|| b64_encode1c(&v)));
    group.bench_function("b64_encode2a", |b| b.iter(|| b64_encode2a(&v)));
    group.bench_function("b64_encode2b", |b| b.iter(|| b64_encode2b(&v)));
    group.finish();
}

criterion_group!(benches, bench);
criterion_main!(benches);