Fix benchmark ratios and pin Rust

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: LessUp

.devcontainer/Dockerfile

@@ -24,6 +24,8 @@ RUN arch="$(dpkg --print-architecture)" \
     && curl -fsSL "https://go.dev/dl/go${GO_VERSION}.linux-${go_arch}.tar.gz" | tar -C /usr/local -xz
 ENV PATH="/usr/local/go/bin:${PATH}"
 
+ARG RUST_VERSION=1.90.0
 USER vscode
-RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --profile minimal --component clippy rustfmt
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain ${RUST_VERSION} --profile minimal --component clippy rustfmt \
+    && /home/vscode/.cargo/bin/rustup default ${RUST_VERSION}
 ENV PATH="/home/vscode/.cargo/bin:${PATH}"

docs/.vitepress/data/benchmarks.json

@@ -6,132 +6,132 @@
       "algorithm": "huffman",
       "language": "cpp",
       "dataset": "textlike_10MiB",
-      "encodeTime": 651.2,
-      "decodeTime": 2263.5,
-      "encodeSpeed": 15.4,
-      "decodeSpeed": 4.4,
-      "compressionRatio": 1.34,
+      "encodeTime": 514.8,
+      "decodeTime": 1874.4,
+      "encodeSpeed": 19.4,
+      "decodeSpeed": 5.3,
+      "compressionRatio": 0.746,
       "throughput": "low"
     },
     {
       "algorithm": "huffman",
       "language": "go",
       "dataset": "textlike_10MiB",
-      "encodeTime": 450.2,
-      "decodeTime": 2592.7,
-      "encodeSpeed": 22.2,
-      "decodeSpeed": 3.9,
-      "compressionRatio": 1.34,
+      "encodeTime": 352.7,
+      "decodeTime": 2344.1,
+      "encodeSpeed": 28.4,
+      "decodeSpeed": 4.3,
+      "compressionRatio": 0.746,
       "throughput": "low"
     },
     {
       "algorithm": "huffman",
       "language": "rust",
       "dataset": "textlike_10MiB",
-      "encodeTime": 916.5,
-      "decodeTime": 1265.7,
-      "encodeSpeed": 10.9,
-      "decodeSpeed": 7.9,
-      "compressionRatio": 1.34,
+      "encodeTime": 808.9,
+      "decodeTime": 1122.6,
+      "encodeSpeed": 12.4,
+      "decodeSpeed": 8.9,
+      "compressionRatio": 0.746,
       "throughput": "low"
     },
     {
       "algorithm": "arithmetic",
       "language": "cpp",
       "dataset": "textlike_10MiB",
-      "encodeTime": 1487.6,
-      "decodeTime": 3749.6,
-      "encodeSpeed": 6.7,
-      "decodeSpeed": 2.7,
-      "compressionRatio": 1.346,
+      "encodeTime": 1293.2,
+      "decodeTime": 3417.7,
+      "encodeSpeed": 7.7,
+      "decodeSpeed": 2.9,
+      "compressionRatio": 0.743,
       "throughput": "low"
     },
     {
       "algorithm": "arithmetic",
       "language": "go",
       "dataset": "textlike_10MiB",
-      "encodeTime": 1705.0,
-      "decodeTime": 3844.3,
-      "encodeSpeed": 5.9,
-      "decodeSpeed": 2.6,
-      "compressionRatio": 1.346,
+      "encodeTime": 1567.4,
+      "decodeTime": 3569.7,
+      "encodeSpeed": 6.4,
+      "decodeSpeed": 2.8,
+      "compressionRatio": 0.743,
       "throughput": "low"
     },
     {
       "algorithm": "arithmetic",
       "language": "rust",
       "dataset": "textlike_10MiB",
-      "encodeTime": 1200.5,
-      "decodeTime": 4903.4,
-      "encodeSpeed": 8.3,
-      "decodeSpeed": 2.0,
-      "compressionRatio": 1.346,
+      "encodeTime": 1101.5,
+      "decodeTime": 4484.3,
+      "encodeSpeed": 9.1,
+      "decodeSpeed": 2.2,
+      "compressionRatio": 0.743,
       "throughput": "low"
     },
     {
       "algorithm": "range",
       "language": "cpp",
       "dataset": "small_dictionary_like",
-      "encodeTime": 7.0,
-      "decodeTime": 11.6,
-      "encodeSpeed": 1.2,
-      "decodeSpeed": 0.7,
-      "compressionRatio": 1.626,
+      "encodeTime": 4.4,
+      "decodeTime": 4.2,
+      "encodeSpeed": 1.9,
+      "decodeSpeed": 2.0,
+      "compressionRatio": 0.615,
       "throughput": "low"
     },
     {
       "algorithm": "range",
       "language": "go",
       "dataset": "small_dictionary_like",
-      "encodeTime": 4.6,
-      "decodeTime": 4.4,
-      "encodeSpeed": 1.8,
-      "decodeSpeed": 1.9,
-      "compressionRatio": 1.626,
+      "encodeTime": 3.1,
+      "decodeTime": 3.1,
+      "encodeSpeed": 2.7,
+      "decodeSpeed": 2.7,
+      "compressionRatio": 0.615,
       "throughput": "low"
     },
     {
       "algorithm": "range",
       "language": "rust",
       "dataset": "small_dictionary_like",
-      "encodeTime": 3.3,
-      "decodeTime": 5.3,
-      "encodeSpeed": 2.5,
-      "decodeSpeed": 1.6,
-      "compressionRatio": 1.626,
+      "encodeTime": 2.1,
+      "decodeTime": 2.2,
+      "encodeSpeed": 4.0,
+      "decodeSpeed": 3.8,
+      "compressionRatio": 0.615,
       "throughput": "low"
     },
     {
       "algorithm": "rle",
       "language": "cpp",
       "dataset": "repetitive_10MiB",
-      "encodeTime": 203.2,
-      "decodeTime": 671.3,
-      "encodeSpeed": 49.2,
-      "decodeSpeed": 14.9,
-      "compressionRatio": 500.0,
+      "encodeTime": 170.0,
+      "decodeTime": 338.2,
+      "encodeSpeed": 58.8,
+      "decodeSpeed": 29.6,
+      "compressionRatio": 0.002,
       "throughput": "medium"
     },
     {
       "algorithm": "rle",
       "language": "go",
       "dataset": "repetitive_10MiB",
-      "encodeTime": 94.6,
-      "decodeTime": 422.6,
-      "encodeSpeed": 105.7,
-      "decodeSpeed": 23.7,
-      "compressionRatio": 500.0,
-      "throughput": "medium"
+      "encodeTime": 72.8,
+      "decodeTime": 289.5,
+      "encodeSpeed": 137.4,
+      "decodeSpeed": 34.5,
+      "compressionRatio": 0.002,
+      "throughput": "high"
     },
     {
       "algorithm": "rle",
       "language": "rust",
       "dataset": "repetitive_10MiB",
-      "encodeTime": 60.9,
-      "decodeTime": 208.4,
-      "encodeSpeed": 164.2,
-      "decodeSpeed": 48.0,
-      "compressionRatio": 500.0,
+      "encodeTime": 36.1,
+      "decodeTime": 167.5,
+      "encodeSpeed": 277.0,
+      "decodeSpeed": 59.7,
+      "compressionRatio": 0.002,
       "throughput": "high"
     }
   ]

docs/.vitepress/theme/components/BenchmarkChart.vue

@@ -88,15 +88,24 @@ const formatMetricName = (metric: string): string => {
   const names: Record<string, string> = {
     encodeSpeed: 'Encode Speed (MiB/s)',
     decodeSpeed: 'Decode Speed (MiB/s)',
-    compressionRatio: 'Compression Ratio'
+    compressionRatio: 'Compression Ratio (lower = better)'
   }
   return names[metric] || metric
 }
 
 const getBarHeight = (value: number): number => {
-  const max = Math.max(maxValue.value, selectedMetric.value === 'compressionRatio' ? 30 : 300)
+  const max = selectedMetric.value === 'compressionRatio'
+    ? Math.max(maxValue.value, 0.001)
+    : Math.max(maxValue.value, 300)
   return Math.max((value / max) * 100, 5)
 }
+
+const formatMetricValue = (value: number): string => {
+  if (selectedMetric.value === 'compressionRatio') {
+    return value < 0.01 ? value.toFixed(3) : value.toFixed(2)
+  }
+  return value.toFixed(value < 10 ? 1 : 0)
+}
 </script>
 
 <template>
@@ -138,7 +147,7 @@ const getBarHeight = (value: number): number => {
             v-for="result in groupedByAlgorithm[algo]" 
             :key="result.language"
             class="bar-wrapper"
-            :title="`${languageNames[result.language]}: ${result[selectedMetric].toFixed(1)}`"
+            :title="`${languageNames[result.language]}: ${formatMetricValue(result[selectedMetric])}`"
           >
             <div 
               class="bar" 
@@ -147,7 +156,7 @@ const getBarHeight = (value: number): number => {
                 backgroundColor: languageColors[result.language]
               }"
             >
-              <span class="bar-value">{{ result[selectedMetric].toFixed(result[selectedMetric] < 10 ? 1 : 0) }}</span>
+              <span class="bar-value">{{ formatMetricValue(result[selectedMetric]) }}</span>
             </div>
           </div>
         </div>

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "1.90.0"

scripts/run_all_bench.py

@@ -134,7 +134,7 @@ def parse_benchmark_output(algorithm, dataset, output):
                 "decodeTime": round(decode_seconds * 1000, 3),
                 "encodeSpeed": round(encode_speed, 1),
                 "decodeSpeed": round(decode_speed, 1),
-                "compressionRatio": round(invert_ratio(ratio), 3),
+                "compressionRatio": round(ratio, 3),
                 "throughput": classify_throughput((encode_speed + decode_speed) / 2.0),
             }
         )
@@ -150,14 +150,6 @@ def compute_speed(size_mib, seconds):
     if seconds <= 0:
         return 0.0
     return size_mib / seconds
-
-
-def invert_ratio(ratio):
-    if ratio <= 0:
-        return 0.0
-    return 1.0 / ratio
-
-
 def classify_throughput(speed_mib_per_second):
     if speed_mib_per_second >= 200:
         return "very-high"

tests/test_run_all_bench.py

@@ -75,7 +75,7 @@ def test_main_refreshes_docs_benchmark_json_from_driver_output(self):
         self.assertAlmostEqual(by_algorithm["huffman"]["decodeTime"], 200.0)
         self.assertAlmostEqual(by_algorithm["huffman"]["encodeSpeed"], 100.0)
         self.assertAlmostEqual(by_algorithm["huffman"]["decodeSpeed"], 50.0)
-        self.assertAlmostEqual(by_algorithm["huffman"]["compressionRatio"], 2.0)
+        self.assertAlmostEqual(by_algorithm["huffman"]["compressionRatio"], 0.5)
 
         report_paths = sorted((self.root / "reports").glob("*_report_*.txt"))
         self.assertEqual(len(report_paths), 4)