nu 0.113.0

A new type of shell
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#!/usr/bin/env nu
# Parse parser benchmark output and report throughput (chars/sec and bytes/sec).
# Compatible with Nushell 0.112.2.

def unit-to-seconds [value: float, unit: string] {
    match $unit {
        "ns" => { $value / 1_000_000_000.0 }
        "us" => { $value / 1_000_000.0 }
        "µs" => { $value / 1_000_000.0 }
        "ms" => { $value / 1_000.0 }
        "s" => { $value }
        _ => { null }
    }
}

def normalize-time-unit [unit: string] {
    let normalized = ($unit | str downcase)

    match $normalized {
        "sec" | "s" | "second" | "seconds" => { "sec" }
        "milli" | "ms" | "millisecond" | "milliseconds" => { "milli" }
        "micro" | "us" | "µs" | "microsecond" | "microseconds" => { "micro" }
        "nano" | "ns" | "nanosecond" | "nanoseconds" => { "nano" }
        _ => { null }
    }
}

def selected-unit-to-seconds [unit: string] {
    match $unit {
        "sec" => { 1.0 }
        "milli" => { 0.001 }
        "micro" => { 0.000001 }
        "nano" => { 0.000000001 }
        _ => { null }
    }
}

def extract-sizes [name: string] {
    let capture = ($name | parse -r '_(?<bytes>[0-9]+)b_(?<chars>[0-9]+)c$')

    if ($capture | is-empty) {
        null
    } else {
        {
            bytes: ($capture.0.bytes | into int)
            chars: ($capture.0.chars | into int)
        }
    }
}

def main [
    log_file?: path   # output file produced by parser-bench-0.112.2-run.nu
    --name-prefix: string = "parser_"
    --time-unit: string = "micro"  # throughput time base: sec|milli|micro|nano
] {
    if $log_file == null {
        error make {
            msg: "Missing required argument: log_file"
            help: "Usage: parser-bench-throughput.nu <log-file>\n\nExample:\n  ./target/debug/nu scripts/parser-bench-throughput.nu target/parser-bench/benchmarks-parser__-20260519-125213.log"
        }
    }

    let normalized_time_unit = (normalize-time-unit $time_unit)
    if $normalized_time_unit == null {
        error make {
            msg: $"unsupported time unit: ($time_unit)"
            help: "supported values: sec, milli, micro, nano"
        }
    }

    let selected_unit_seconds = (selected-unit-to-seconds $normalized_time_unit)

    let rows = (
        open $log_file
        | lines
        | parse -r '^(?<name>parser_[A-Za-z0-9_]+)\s+\[.*?\.\.\.\s*(?<value>[0-9]+(?:\.[0-9]+)?)\s*(?<unit>ns|us|µs|ms|s)\s*\.\.\.'
        | where {|row| $row.name | str starts-with $name_prefix }
        | each {|row|
            let seconds = (unit-to-seconds ($row.value | into float) $row.unit)
            let sizes = (extract-sizes $row.name)
            let unit_time = if $seconds == null {
                null
            } else {
                $seconds / $selected_unit_seconds
            }

            if ($seconds == null or $sizes == null or $unit_time == null or $unit_time == 0.0) {
                null
            } else {
                {
                    benchmark: $row.name
                    seconds: ($seconds | into float)
                    chars: $sizes.chars
                    bytes: $sizes.bytes
                    time_unit: $normalized_time_unit
                    chars_per_unit: (($sizes.chars | into float) / $unit_time)
                    bytes_per_unit: (($sizes.bytes | into float) / $unit_time)
                }
            }
        }
        | compact
        | uniq-by benchmark
        | sort-by benchmark
    )

    if ($rows | is-empty) {
        error make {
            msg: "no parser benchmark rows were parsed"
            help: "ensure the log contains parser benchmark output lines with timing units"
        }
    }

    print $"Throughput summary \(derived from benchmark timing, unit: ($normalized_time_unit)\):"
    print ($rows
    | select benchmark chars bytes seconds time_unit chars_per_unit bytes_per_unit
    | table)

    print $"\nHeadline metric candidates \(chars/($normalized_time_unit)\):"
    print ($rows
    | sort-by chars_per_unit --reverse
    | first 5
    | select benchmark chars_per_unit
    | table)

    # print "\nFull table of all parsed benchmarks with throughput metrics:"
    # print $rows
    
    print $"\nBenchmark logfile: ($log_file)"
    open $log_file
}