2021-01-10 03:50:49 +01:00
|
|
|
[package]
|
2022-03-22 21:25:38 +01:00
|
|
|
authors = ["The Nushell Project Developers"]
|
2022-04-11 20:17:06 +02:00
|
|
|
description = "Nushell's evaluation engine"
|
2022-08-14 14:21:20 +02:00
|
|
|
repository = "https://github.com/nushell/nushell/tree/main/crates/nu-engine"
|
2022-03-22 21:25:38 +01:00
|
|
|
edition = "2021"
|
|
|
|
|
license = "MIT"
|
2021-01-10 03:50:49 +01:00
|
|
|
name = "nu-engine"
|
2024-08-22 11:36:32 +02:00
|
|
|
version = "0.97.2"
|
2021-08-10 20:51:08 +02:00
|
|
|
|
2023-02-12 23:22:00 +01:00
|
|
|
[lib]
|
|
|
|
|
bench = false
|
|
|
|
|
|
2024-08-28 23:37:17 +02:00
|
|
|
[lints]
|
|
|
|
|
workspace = true
|
|
|
|
|
|
2021-08-10 20:51:08 +02:00
|
|
|
[dependencies]
|
2024-08-22 11:36:32 +02:00
|
|
|
nu-protocol = { path = "../nu-protocol", features = ["plugin"], version = "0.97.2" }
|
|
|
|
|
nu-path = { path = "../nu-path", version = "0.97.2" }
|
|
|
|
|
nu-glob = { path = "../nu-glob", version = "0.97.2" }
|
|
|
|
|
nu-utils = { path = "../nu-utils", version = "0.97.2" }
|
Internal representation (IR) compiler and evaluator (#13330)
# Description
This PR adds an internal representation language to Nushell, offering an
alternative evaluator based on simple instructions, stream-containing
registers, and indexed control flow. The number of registers required is
determined statically at compile-time, and the fixed size required is
allocated upon entering the block.
Each instruction is associated with a span, which makes going backwards
from IR instructions to source code very easy.
Motivations for IR:
1. **Performance.** By simplifying the evaluation path and making it
more cache-friendly and branch predictor-friendly, code that does a lot
of computation in Nushell itself can be sped up a decent bit. Because
the IR is fairly easy to reason about, we can also implement
optimization passes in the future to eliminate and simplify code.
2. **Correctness.** The instructions mostly have very simple and
easily-specified behavior, so hopefully engine changes are a little bit
easier to reason about, and they can be specified in a more formal way
at some point. I have made an effort to document each of the
instructions in the docs for the enum itself in a reasonably specific
way. Some of the errors that would have happened during evaluation
before are now moved to the compilation step instead, because they don't
make sense to check during evaluation.
3. **As an intermediate target.** This is a good step for us to bring
the [`new-nu-parser`](https://github.com/nushell/new-nu-parser) in at
some point, as code generated from new AST can be directly compared to
code generated from old AST. If the IR code is functionally equivalent,
it will behave the exact same way.
4. **Debugging.** With a little bit more work, we can probably give
control over advancing the virtual machine that `IrBlock`s run on to
some sort of external driver, making things like breakpoints and single
stepping possible. Tools like `view ir` and [`explore
ir`](https://github.com/devyn/nu_plugin_explore_ir) make it easier than
before to see what exactly is going on with your Nushell code.
The goal is to eventually replace the AST evaluator entirely, once we're
sure it's working just as well. You can help dogfood this by running
Nushell with `$env.NU_USE_IR` set to some value. The environment
variable is checked when Nushell starts, so config runs with IR, or it
can also be set on a line at the REPL to change it dynamically. It is
also checked when running `do` in case within a script you want to just
run a specific piece of code with or without IR.
# Example
```nushell
view ir { |data|
mut sum = 0
for n in $data {
$sum += $n
}
$sum
}
```
```gas
# 3 registers, 19 instructions, 0 bytes of data
0: load-literal %0, int(0)
1: store-variable var 904, %0 # let
2: drain %0
3: drop %0
4: load-variable %1, var 903
5: iterate %0, %1, end 15 # for, label(1), from(14:)
6: store-variable var 905, %0
7: load-variable %0, var 904
8: load-variable %2, var 905
9: binary-op %0, Math(Plus), %2
10: span %0
11: store-variable var 904, %0
12: load-literal %0, nothing
13: drain %0
14: jump 5
15: drop %0 # label(0), from(5:)
16: drain %0
17: load-variable %0, var 904
18: return %0
```
# Benchmarks
All benchmarks run on a base model Mac Mini M1.
## Iterative Fibonacci sequence
This is about as best case as possible, making use of the much faster
control flow. Most code will not experience a speed improvement nearly
this large.
```nushell
def fib [n: int] {
mut a = 0
mut b = 1
for _ in 2..=$n {
let c = $a + $b
$a = $b
$b = $c
}
$b
}
use std bench
bench { 0..50 | each { |n| fib $n } }
```
IR disabled:
```
╭───────┬─────────────────╮
│ mean │ 1ms 924µs 665ns │
│ min │ 1ms 700µs 83ns │
│ max │ 3ms 450µs 125ns │
│ std │ 395µs 759ns │
│ times │ [list 50 items] │
╰───────┴─────────────────╯
```
IR enabled:
```
╭───────┬─────────────────╮
│ mean │ 452µs 820ns │
│ min │ 427µs 417ns │
│ max │ 540µs 167ns │
│ std │ 17µs 158ns │
│ times │ [list 50 items] │
╰───────┴─────────────────╯
```
##
[gradient_benchmark_no_check.nu](https://github.com/nushell/nu_scripts/blob/main/benchmarks/gradient_benchmark_no_check.nu)
IR disabled:
```
╭───┬──────────────────╮
│ 0 │ 27ms 929µs 958ns │
│ 1 │ 21ms 153µs 459ns │
│ 2 │ 18ms 639µs 666ns │
│ 3 │ 19ms 554µs 583ns │
│ 4 │ 13ms 383µs 375ns │
│ 5 │ 11ms 328µs 208ns │
│ 6 │ 5ms 659µs 542ns │
╰───┴──────────────────╯
```
IR enabled:
```
╭───┬──────────────────╮
│ 0 │ 22ms 662µs │
│ 1 │ 17ms 221µs 792ns │
│ 2 │ 14ms 786µs 708ns │
│ 3 │ 13ms 876µs 834ns │
│ 4 │ 13ms 52µs 875ns │
│ 5 │ 11ms 269µs 666ns │
│ 6 │ 6ms 942µs 500ns │
╰───┴──────────────────╯
```
##
[random-bytes.nu](https://github.com/nushell/nu_scripts/blob/main/benchmarks/random-bytes.nu)
I got pretty random results out of this benchmark so I decided not to
include it. Not clear why.
# User-Facing Changes
- IR compilation errors may appear even if the user isn't evaluating
with IR.
- IR evaluation can be enabled by setting the `NU_USE_IR` environment
variable to any value.
- New command `view ir` pretty-prints the IR for a block, and `view ir
--json` can be piped into an external tool like [`explore
ir`](https://github.com/devyn/nu_plugin_explore_ir).
# Tests + Formatting
All tests are passing with `NU_USE_IR=1`, and I've added some more eval
tests to compare the results for some very core operations. I will
probably want to add some more so we don't have to always check
`NU_USE_IR=1 toolkit test --workspace` on a regular basis.
# After Submitting
- [ ] release notes
- [ ] further documentation of instructions?
- [ ] post-release: publish `nu_plugin_explore_ir`
2024-07-11 02:33:59 +02:00
|
|
|
log = { workspace = true }
|
Fix overflow table display in command documentation (#13526)
# Description
Check and set table width beforehand.
Closes #13520.
# User-Facing Changes
Before:
```plain
❯ help net cmd1
network
Usage:
> net cmd1
Flags:
-h, --help - Display the help message for this command
Input/output types:
╭───┬─────────┬─────────────────────────────────────────────────────────╮
│ # │ input │ output │
├───┼─────────┼─────────────────────────────────────────────────────────┤
│ 0 │ nothing │ table<name: string, description: string, mac: string, │
│ │ │ ips: table<type: string, addr: string, prefix: int>,
│
│ │ │ flags: record<is_up: bool, is_broadcast: bool,
│
│ │ │ is_loopback: bool, is_point_to_point: bool,
│
│ │ │ is_multicast: bool>>
│
╰───┴─────────┴─────────────────────────────────────────────────────────╯
```
After:
```plain
❯ help net cmd1
network
Usage:
> net cmd1
Flags:
-h, --help - Display the help message for this command
Input/output types:
╭───┬─────────┬───────────────────────────────────────────────────────╮
│ # │ input │ output │
├───┼─────────┼───────────────────────────────────────────────────────┤
│ 0 │ nothing │ table<name: string, description: string, mac: string, │
│ │ │ ips: table<type: string, addr: string, prefix: int>, │
│ │ │ flags: record<is_up: bool, is_broadcast: bool, │
│ │ │ is_loopback: bool, is_point_to_point: bool, │
│ │ │ is_multicast: bool>> │
╰───┴─────────┴───────────────────────────────────────────────────────╯
```
# Tests + Formatting
- [x] `cargo fmt --all -- --check` to check standard code formatting
(`cargo fmt --all` applies these changes)
- [x] `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used`
to check that you're using the standard code style
- [x] `cargo test --workspace` to check that all tests pass (on Windows
make sure to [enable developer
mode](https://learn.microsoft.com/en-us/windows/apps/get-started/developer-mode-features-and-debugging))
- [x] `cargo run -- -c "use toolkit.nu; toolkit test stdlib"` to run the
tests for the standard library
# After Submitting
- [x] Bug fix, no doc update.
2024-08-03 10:55:35 +02:00
|
|
|
terminal_size = { workspace = true }
|
2022-03-13 19:30:27 +01:00
|
|
|
|
2021-12-02 07:35:32 +01:00
|
|
|
[features]
|
2024-08-28 23:37:17 +02:00
|
|
|
plugin = []
|
