base64-ng 2.0.0

no_std-first Base64 encoding and decoding with strict APIs and a security-heavy release process
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

#!/usr/bin/env python3
"""Mutation checks for the Commit 25/26 performance validator."""

import csv
import os
import subprocess
import tempfile
from pathlib import Path


HEADER = [
    "backend",
    "alphabet",
    "padding",
    "input_len",
    "sample_index",
    "iterations",
    "elapsed_ns",
    "throughput_mib_s",
]
LENGTHS = {
    "scalar": (12, 24, 48, 64, 96, 192, 384, 768, 1024, 64 * 1024),
    "ssse3-sse4.1": (12, 24, 48, 64, 96, 192, 384, 768, 1024, 64 * 1024),
    "avx2": (24, 48, 64, 96, 192, 384, 768, 1024, 64 * 1024),
    "avx512-vbmi": (48, 64, 96, 192, 384, 768, 1024, 64 * 1024),
}


def rows() -> list[list[object]]:
    output = []
    for backend, lengths in LENGTHS.items():
        if backend == "scalar":
            throughput = 100.0
        elif backend == "avx512-vbmi":
            throughput = 120.0
        else:
            throughput = 110.0
        for alphabet in ("standard", "url-safe"):
            for padding in ("padded", "unpadded"):
                for input_len in lengths:
                    for sample in range(15):
                        output.append(
                            [backend, alphabet, padding, input_len, sample, 1, 1, throughput]
                        )
    return output


def validate(path: Path, expect_success: bool) -> None:
    result = subprocess.run(
        ["scripts/validate-x86-encode-performance.py", str(path)],
        check=False,
        capture_output=True,
        text=True,
    )
    if (result.returncode == 0) != expect_success:
        raise SystemExit(result.stdout + result.stderr)


def write(path: Path, evidence: list[list[object]]) -> None:
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.writer(handle)
        writer.writerow(HEADER)
        writer.writerows(evidence)


def main() -> None:
    with tempfile.TemporaryDirectory() as directory:
        path = Path(directory) / "evidence.csv"
        evidence = rows()
        write(path, evidence)
        validate(path, True)

        missing = evidence[:-1]
        write(path, missing)
        validate(path, False)

        slow = rows()
        for row in slow:
            if row[0] == "avx2" and row[1:4] == ["standard", "padded", 24]:
                row[-1] = 99.0
        write(path, slow)
        validate(path, False)

        slow_avx512 = rows()
        for row in slow_avx512:
            if row[0] == "avx512-vbmi" and row[1:4] == ["standard", "padded", 192]:
                row[-1] = 112.0
        write(path, slow_avx512)
        validate(path, False)

        write(path, rows())
        validate_with_weakened_environment(path)
    print("x86 encode performance validator: mutation checks ok")


def validate_with_weakened_environment(path: Path) -> None:
    environment = os.environ.copy()
    environment["BASE64_NG_X86_ENCODE_RATIO"] = "0.50"
    result = subprocess.run(
        ["scripts/validate-x86-encode-performance.py", str(path)],
        check=False,
        capture_output=True,
        text=True,
        env=environment,
    )
    if result.returncode == 0:
        raise SystemExit("weakened encode threshold was accepted")


if __name__ == "__main__":
    main()