comparing `jwalk` and `glob`

[amtoine]

just wanted to report some time measurements i made to test this plugin 😉

the script

Note
$env.GIT_REPOS_HOME is where is store all my Git repos

use std [assert, bench]

let jwalk = {name: "jwalk", code: { jwalk $env.GIT_REPOS_HOME }}
let glob = {name: "glob", code: { glob $"($env.GIT_REPOS_HOME)/**" }}

print --no-newline "making sure outputs are the same... "
assert equal (do $jwalk.code | sort) (do $glob.code | sort)
print "ok"

let res = [$jwalk, $glob] | each {|it|
    print $"benchmarking ($it.name)"
    $it | merge (bench --rounds 10 --verbose $it.code)
}

the results

jwalk and glob report the same 389505 files 👌

jwalk is quite a lot faster than glob 😏

> $res | select name mean std
#┬name─┬────────mean─────────┬───────std───────
0│jwalk│    610ms 292µs 458ns│ 31ms 417µs 956ns
1│glob │2sec 30ms 361µs 668ns│387ms 708µs 127ns
─┴─────┴─────────────────────┴─────────────────

[fdncred]

@amtoine Some testing that I've done shows that jwalk is even faster when supplying multiple --threads. It can also print out it's own speed (before printing to the screen) with the --debug command. Also, I wouldn't do | sort because you're defeating the power of having a --sort command built into jwalk. So, while you're benchmarks are interesting, you're kind of crippling jwalk when you don't need to.

There are quite a few parameters to experiement with.

❯ help jwalk
View jwalk results

Usage:
  > jwalk {flags} <path>

Flags:
  -h, --help - Display the help message for this command
  -s, --sort - sort by file name
  -c, --custom - custom walker with process_read_dir
  -k, --skip-hidden - skip hidden files
  -f, --follow-links - follow symbolic links
  -d, --debug - print performance metrics at the end of the table
  -m, --min-depth <Int> - minimum depth to search
  -x, --max-depth <Int> - maximum depth to search
  -t, --threads <Int> - number of rayon threads to use

Parameters:
  path <string>: path to jwalk

Examples:
  This is the example descripion
  > some pipeline involving jwalk

[amtoine]

i've added more number of threads

use std [assert, bench]

let target = $env.GIT_REPOS_HOME

let jwalk = {name: "jwalk", code: { jwalk $target }}
let jwalk_2 = {name: "jwalk_2", code: { jwalk $target --threads 2 }}
let jwalk_4 = {name: "jwalk_4", code: { jwalk $target --threads 4 }}
let jwalk_8 = {name: "jwalk_8", code: { jwalk $target --threads 8 }}
let jwalk_16 = {name: "jwalk_16", code: { jwalk $target --threads 16 }}
let jwalk_32 = {name: "jwalk_32", code: { jwalk $target --threads 32 }}
let glob = {name: "glob", code: { glob $"($target)/**" }}

print --no-newline "making sure outputs are the same... "
assert equal (do $jwalk.code | sort) (do $glob.code | sort)
print "ok"

let res = [$jwalk, $jwalk_2 , $jwalk_4 , $jwalk_8 , $jwalk_16 , $jwalk_32, $glob] | each {|it|
    print $"benchmarking ($it.name)"
    $it | merge (bench --rounds 10 --verbose $it.code)
}

#┬──name──┬─────────mean─────────┬──────std───────
0│jwalk   │     644ms 787µs 273ns│33ms 694µs 869ns
1│jwalk_2 │  1sec 4ms 472µs 970ns│47ms 348µs 374ns
2│jwalk_4 │     874ms 563µs 888ns│29ms 544µs 272ns
3│jwalk_8 │     877ms 854µs 519ns│13ms 657µs 584ns
4│jwalk_16│     941ms 671µs 557ns│50ms 756µs 547ns
5│jwalk_32│     928ms 240µs 109ns│28ms 674µs 224ns
6│glob    │1sec 535ms 579µs 826ns│20ms 886µs 970ns
─┴────────┴──────────────────────┴────────────────

not much better with multiple threads 🤔

Important
these times come from my personal machine, without a proper infrastructure to run benchmarks.

also the Nushell overhead is quite significant 😮

• measuring jwalk's internal time

> jwalk $env.GIT_REPOS_HOME --debug | last | parse "Time: {time}" | get time.0 | into duration
354ms 849µs

• measuring with timeit

> timeit { jwalk $env.GIT_REPOS_HOME }
597ms 496µs 132ns

[amtoine]

i've just run another one 😏

this time trying to compare glob with proper globbing and jwalk + find --invert
TLDR: jwalk is around 2x faster 😆

use std [assert, bench]

let target = $env.GIT_REPOS_HOME

let glob = {
    name: "glob",
    code: {
        glob $"($target)/**/HEAD" --not [
            **/.git/**/refs/remotes/**/HEAD,
            **/.git/modules/**/HEAD,
            **/logs/HEAD
        ]
    }
}
let jwalk = {
    name: "jwalk",
    code: {
        jwalk $target
            | find --regex '/HEAD$'
            | find --invert --regex '.*/\.git.*/refs/remotes/.*/HEAD'
            | find --invert --regex '.*/\.git/modules/.*/HEAD'
            | find --invert --regex '.*/logs/HEAD'
    }
}

print "making sure outputs are the same... "
assert equal (do $jwalk.code | sort) (do $glob.code | sort)
print "ok"

let res = [$jwalk, $glob] | each {|it|
    print $"benchmarking ($it.name)"
    $it | merge (bench --rounds 10 --verbose $it.code)
}

gives

#┬name─┬────────mean─────────┬──────std───────
0│jwalk│     653ms 811µs 78ns│41ms 898µs 332ns
1│glob │1sec 110ms 643µs 27ns│74ms 110µs 699ns
─┴─────┴─────────────────────┴────────────────

[fdncred]

I guess threads depends on your system ssd/hdd. This is what I get on MacOS.

❯ $res | select name mean std
╭#┬──name──┬──────mean───────┬──────std──────╮
│0│jwalk   │160ms 887µs 487ns│2ms 103µs 659ns│
│1│jwalk_2 │200ms 342µs 216ns│2ms 573µs 768ns│
│2│jwalk_4 │161ms 738µs 520ns│23ms 209µs 64ns│
│3│jwalk_8 │157ms 452µs 741ns│4ms 758µs 998ns│
│4│jwalk_16│160ms 516µs 766ns│1ms 657µs 696ns│
│5│jwalk_32│167ms 109µs 183ns│5ms 175µs 890ns│
│6│glob    │337ms 346µs 250ns│3ms 876µs 521ns│
╰#┴──name──┴──────mean───────┴──────std──────╯

[fdncred]

I think it's pretty conclusive though that jwalk has merit. We just need to figure out where/how to add it. To figure this out, we'll need to do some testing to see if some type of globbing can be added. We may be able to add something that calls str expand so it makes a pseudo-glob. Not sure.