slice performance

Offen
#571 13 Kommentare 0 Reaktionen 0 zugewiesene Personen Auf GitHub ansehen

Dieses Issue hat noch niemand übernommen.

Bewertung

Schwierigkeit
4/5
Geschätzter Aufwand
3-5 Tage
Anfängerfreundlichkeit
35/100
Issue-Typ
Bug
Klarheit
Muss geklärt werden
Aktivitätsstatus
Veraltet
Tech-Stack
rust
Bereich
performance

Rechercherichtung

Start with the reported bench_loop and bench_slice benchmarks, comparing test_loop with test_slice on the same 3x3x3 patches in an 11x11x11 Array3. Inspect the slice and azip paths in the referenced src or lib code and determine what accounts for the timing difference. Done means explaining the slowdown and identifying whether the clean implementation can match the loop without changing its result.

Vom Indexierungsmodell aus dem Issue-Text verfasst.

Beschreibung

performance

Don't try to understand my first version too much, the second function is much simpler. It's simply comparing two 3x3x3 patches of data in a 11x11x11 image and returning a score. I refactored this function from

fn test_loop(data: &[f64], m: usize, n: usize, o: usize) -> f64 {
    let pl = 3;
    let br = 4;
    let bl = 11;
    let bl2 = bl * bl;
    let mut sum = 0.0;
    for a in 0..pl {
        let idx1_a = (br + a) * bl2;
        let idx2_a = (m + a) * bl2;
        for b in 0..pl {
            let idx1_b = (br + b) * bl;
            let idx2_b = (n + b) * bl;
            for c in 0..pl {
                let idx1 = idx1_a + idx1_b + br + c;
                let idx2 = idx2_a + idx2_b + o + c;
                let diff = (data[idx1] - data[idx2]).powi(2);
                sum += diff;
            }
        }
    }
    sum
}

to

fn test_slice(data: &Array3<f64>, m: usize, n: usize, o: usize) -> f64 {
    let pl = 3;
    let br = 4;
    let s1 = data.slice(s![br..br+pl, br..br+pl, br..br+pl]);
    let s2 = data.slice(s![m..m+pl, n..n+pl, o..o+pl]);

    let mut sum = 0.0;
    azip!(s1, s2 in { sum += (s1 - s2).powi(2) });
    sum
}

Of course, I'm happy with the code quality now (!), but the clean version is surprisingly slow. I benched those 2 functions using the same data, with test_loop using &data.as_slice().unwrap() instead of &data

test bench_loop              ... bench:          25 ns/iter (+/- 5)
test bench_slice             ... bench:         142 ns/iter (+/- 1)

Are those results surprising to you? Both versions don't allocate, calculate the indices (in src or lib) and the sum, etc. I fail to see why the clean version is almost 6 times slower. Is slice doing something really complex?

Vorherrschende Sprache
Rust
Sterne
4.3k
Forks
391
Keine gemergten PRs in 30 T.

Beitragsleitfaden

Für dieses Repository ist kein Beitragsleitfaden indexiert

Erste Schritte

  1. Lesen Sie das ganze Issue und danach den Beitragsleitfaden des Projekts.
  2. Schreiben Sie ins Issue, dass Sie es übernehmen — das erspart doppelte Arbeit.
  3. Forken Sie das Repository und arbeiten Sie in einem Branch.
  4. Öffnen Sie einen Pull Request, der die Issue-Nummer nennt.

Mehr aus rust-ndarray/ndarray

Alle Issues in rust-ndarray/ndarray

Ähnliche Issues

Weitere Issues zu Rust

Neue Issues direkt in Ihr Postfach

Eine kurze Übersicht über anfängerfreundliche GitHub-Issues.