Rust: write!(wr,"foo") wr.write("foo.as_bytes()) की तुलना में 10% से 72% धीमी है।

को निर्मित 2 दिस॰ 2013 · 9टिप्पणियाँ · स्रोत: rust-lang/rust

यह उदाहरण दर्शाता है कि तुच्छ मामले write!(wr, "foo") ज्यादा बुला की तुलना में धीमी है wr.write("foo".as_bytes()) :

extern mod extra;

use std::io::mem::MemWriter;
use extra::test::BenchHarness;

#[bench]
fn bench_write_value(bh: &mut BenchHarness) {
    bh.iter(|| {
        let mut mem = MemWriter::new();
        for _ in range(0, 1000) {
            mem.write("abc".as_bytes());
        }
    });
}

#[bench]
fn bench_write_ref(bh: &mut BenchHarness) {
    bh.iter(|| {
        let mut mem = MemWriter::new();
        let wr = &mut mem as &mut Writer;
        for _ in range(0, 1000) {
            wr.write("abc".as_bytes());
        }
    });
}

#[bench]
fn bench_write_macro1(bh: &mut BenchHarness) {
    bh.iter(|| {
        let mut mem = MemWriter::new();
        let wr = &mut mem as &mut Writer;
        for _ in range(0, 1000) {
            write!(wr, "abc");
        }
    });
}

#[bench]
fn bench_write_macro2(bh: &mut BenchHarness) {
    bh.iter(|| {
        let mut mem = MemWriter::new();
        let wr = &mut mem as &mut Writer;
        for _ in range(0, 1000) {
            write!(wr, "{}", "abc");
        }
    });
}

बिना किसी अनुकूलन के:

running 4 tests
test bench_write_macro1 ... bench:    280153 ns/iter (+/- 73615)
test bench_write_macro2 ... bench:    322462 ns/iter (+/- 24886)
test bench_write_ref    ... bench:     79974 ns/iter (+/- 3850)
test bench_write_value  ... bench:     78709 ns/iter (+/- 4003)

test result: ok. 0 passed; 0 failed; 0 ignored; 4 measured

--opt-level=3 :

running 4 tests
test bench_write_macro1 ... bench:     62397 ns/iter (+/- 5485)
test bench_write_macro2 ... bench:     80203 ns/iter (+/- 3355)
test bench_write_ref    ... bench:     55275 ns/iter (+/- 5156)
test bench_write_value  ... bench:     56273 ns/iter (+/- 7591)

test result: ok. 0 passed; 0 failed; 0 ignored; 4 measured

क्या इसे सुधारने के लिए हम कुछ कर सकते हैं? मैं कुछ विकल्पों के बारे में सोच सकता हूं, लेकिन मुझे यकीन है कि और भी हैं:

write! में संकलित करने के लिए विशेष मामला नो-तर्क wr.write("foo".as_bytes()) । अगर हम इस मार्ग पर जाते हैं, तो str write!("foo {} {}", "bar", "baz") एक श्रृंखला को भी रूपांतरित करना अच्छा होगा।
wr.write_str("foo") पुनर्जीवित करें। मुझे जो समझ आ रहा है, उससे #6164 पर ब्लॉक किया जा रहा है।
पता लगाएँ कि llvm write! ओवरहेड को ऑप्टिमाइज़ करने में सक्षम क्यों नहीं है। क्या ऐसे कार्य हैं जिन्हें रेखांकित किया जाना चाहिए जो नहीं हैं? मेरे स्कैटर शॉट प्रयास का कोई परिणाम नहीं निकला।

C-enhancement I-slow T-compiler T-libs

स्रोत

erickt

सभी 9 टिप्पणियाँ

मुझे संदेह है कि fn bench_write_ref वर्चुअल कॉल नहीं करता है। इसे जोड़ना

#[inline(never)]
fn writer_write(w: &mut Writer, b: &[u8]) {
    w.write(b);
}

#[bench]
fn bench_write_virt(bh: &mut BenchHarness) {
    bh.iter(|| {
        let mut mem = MemWriter::new();
        let wr = &mut mem as &mut Writer;
        for _ in range(0, 1000) {
            writer_write(wr, "abc".as_bytes());
        }
    });
}

मेरे पास --opt-level 3

running 5 tests
test bench_write_macro1 ... bench:    680823 ns/iter (+/- 34497)
test bench_write_macro2 ... bench:    950790 ns/iter (+/- 72309)
test bench_write_ref    ... bench:    505846 ns/iter (+/- 41965)
test bench_write_value  ... bench:    511815 ns/iter (+/- 36681)
test bench_write_virt   ... bench:    553466 ns/iter (+/- 43716)

तो, वर्चुअल कॉल का प्रभाव पड़ता है, लेकिन यह इस बेंच द्वारा दिखाए गए write!() की सुस्ती को पूरी तरह से स्पष्ट नहीं करता है।

TeXitoi 2 दिस॰ 2013

बग ट्राइएज के लिए विजिटिंग। ऐसा लगता है कि यह अभी भी मौजूद है। बेंचमार्क चलाने के लिए कोड अब है:

extern crate test;

use std::io::MemWriter;
use test::Bencher;

#[bench]
fn bench_write_value(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = MemWriter::new();
        for _ in range(0u, 1000) {
            mem.write("abc".as_bytes());
        }
    });
}

#[bench]
fn bench_write_ref(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = MemWriter::new();
        let wr = &mut mem as &mut Writer;
        for _ in range(0u, 1000) {
            wr.write("abc".as_bytes());
        }
    });
}

#[bench]
fn bench_write_macro1(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = MemWriter::new();
        let wr = &mut mem as &mut Writer;
        for _ in range(0u, 1000) {
            write!(wr, "abc");
        }
    });
}

#[bench]
fn bench_write_macro2(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = MemWriter::new();
        let wr = &mut mem as &mut Writer;
        for _ in range(0u, 1000) {
            write!(wr, "{}", "abc");
        }
    });
}

अनुकूलन के बिना:

running 4 tests
test bench_write_macro1 ... bench:   1470468 ns/iter (+/- 291966)
test bench_write_macro2 ... bench:   1799612 ns/iter (+/- 316293)
test bench_write_ref    ... bench:   1336574 ns/iter (+/- 251664)
test bench_write_value  ... bench:   1317880 ns/iter (+/- 254668)

test result: ok. 0 passed; 0 failed; 0 ignored; 4 measured

--opt-level=3 :

running 4 tests
test bench_write_macro1 ... bench:    127671 ns/iter (+/- 1452)
test bench_write_macro2 ... bench:    196158 ns/iter (+/- 2053)
test bench_write_ref    ... bench:     43881 ns/iter (+/- 453)
test bench_write_value  ... bench:     43859 ns/iter (+/- 336)

test result: ok. 0 passed; 0 failed; 0 ignored; 4 measured

nham 7 अग॰ 2014

निम्नलिखित कोड का उपयोग करके अभी भी एक समस्या है:

#![allow(unused_must_use)]
#![feature(test)]

extern crate test;

use std::io::Write;
use std::vec::Vec;

use test::Bencher;

#[bench]
fn bench_write_value(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = Vec::new();
        for _ in 0..1000 {
            mem.write("abc".as_bytes());
        }
    });
}

#[bench]
fn bench_write_ref(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = Vec::new();
        let wr = &mut mem as &mut Write;
        for _ in 0..1000 {
            wr.write("abc".as_bytes());
        }
    });
}

#[bench]
fn bench_write_macro1(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = Vec::new();
        let wr = &mut mem as &mut Write;
        for _ in 0..1000 {
            write!(wr, "abc");
        }
    });
}

#[bench]
fn bench_write_macro2(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = Vec::new();
        let wr = &mut mem as &mut Write;
        for _ in 0..1000 {
            write!(wr, "{}", "abc");
        }
    });
}

आमतौर पर निम्नलिखित की तरह कुछ दे रहा है:

$ cargo bench
running 4 tests
test bench_write_macro1 ... bench:      21,604 ns/iter (+/- 82)
test bench_write_macro2 ... bench:      29,273 ns/iter (+/- 85)
test bench_write_ref    ... bench:       1,396 ns/iter (+/- 387)
test bench_write_value  ... bench:       1,391 ns/iter (+/- 163)

Toby-S 30 अक्तू॰ 2015

मुझे रात में जंग के साथ लगभग समान परिणाम मिले।

ariasuni 23 जून 2017

केवल रिकॉर्ड के लिए, v1.20.0-nightly साथ चल रहा है:

$ cargo bench
running 4 tests
test bench_write_macro1 ... bench:      36,556 ns/iter (+/- 69)
test bench_write_macro2 ... bench:      54,377 ns/iter (+/- 958)
test bench_write_ref    ... bench:      13,730 ns/iter (+/- 24)
test bench_write_value  ... bench:      13,755 ns/iter (+/- 81)

ritiek 14 जुल॰ 2017

आज:

running 4 tests
test bench_write_macro1 ... bench:      16,220 ns/iter (+/- 982)
test bench_write_macro2 ... bench:      25,542 ns/iter (+/- 2,220)
test bench_write_ref    ... bench:       4,889 ns/iter (+/- 314)
test bench_write_value  ... bench:       4,819 ns/iter (+/- 956)

steveklabnik 24 सित॰ 2018

😕3

दो साल बाद:

running 4 tests
test bench_write_macro1 ... bench:      17,561 ns/iter (+/- 174)
test bench_write_macro2 ... bench:      23,285 ns/iter (+/- 2,771)
test bench_write_ref    ... bench:       3,234 ns/iter (+/- 194)
test bench_write_value  ... bench:       3,238 ns/iter (+/- 123)

test result: ok. 0 passed; 0 failed; 0 ignored; 4 measured; 0 filtered out

❯ rustc +nightly --version
rustc 1.47.0-nightly (30f0a0768 2020-08-18)

steveklabnik 26 अग॰ 2020

मैं उत्सुक था अगर अंतर io::Write बनाम fmt::Write के कार्यान्वयन में था, या write_fmt के विवरण में format_args की आवश्यकता थी!, जो लिखने के बाद से प्रासंगिक है! किसी भी मामले में "सेवा" करने के लिए कहा जा सकता है।

इस बारे में अधिक जानकारी खोजने के लिए, मैंने वीईसी की तुलना स्ट्रिंग से की, एक प्रतीत होता है "सेब से सेब ... ईश" तुलना। https://gist.github.com/workingjubilee/2d2e3a7fded1c2101aafb51dc79a7ec5

running 10 tests
test string_write_fmt    ... bench:      10,053 ns/iter (+/- 1,141)
test string_write_macro1 ... bench:      10,177 ns/iter (+/- 2,363)
test string_write_macro2 ... bench:      17,499 ns/iter (+/- 1,847)
test string_write_ref    ... bench:       2,270 ns/iter (+/- 265)
test string_write_value  ... bench:       2,333 ns/iter (+/- 126)
test vec_write_fmt       ... bench:      15,722 ns/iter (+/- 1,673)
test vec_write_macro1    ... bench:      15,767 ns/iter (+/- 1,638)
test vec_write_macro2    ... bench:      23,968 ns/iter (+/- 8,942)
test vec_write_ref       ... bench:       2,296 ns/iter (+/- 178)
test vec_write_value     ... bench:       2,230 ns/iter (+/- 235)

test result: ok. 0 passed; 0 failed; 0 ignored; 10 measured; 0 filtered out

workingjubilee 6 सित॰ 2020

मुझे यह दिलचस्प लगा कि इस उदाहरण से पता चला कि स्ट्रिंग वास्तव में write! पर Vec से कम ओवरहेड था (बेंचमार्क में उच्च भिन्नता थी लेकिन मैंने इसे पर्याप्त संकेतक माना)।

फिर मैंने देखा और देखा:

    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> Result<()> {
        // Create a shim which translates an io::Write to a fmt::Write and saves
        // off I/O errors. instead of discarding them
        struct Adaptor<'a, T: ?Sized + 'a> {
            inner: &'a mut T,
            error: Result<()>,
        }

        /* More code related to implementing and using the resulting shim,
         * seemingly involving a lot of poking a reference at runtime??? */
    }

इसलिए अब मुझे आश्चर्य नहीं होता।
मेरा मानना है कि कुछ मामलों को फास्ट-पाथ करना संभव है, लेकिन यह वास्तव में यहां सेब-से-सेब की तुलना नहीं है। संतरा है write_fmt , जिसमें विभिन्न प्रकार की स्वरूपण मशीनरी का उपयोग करना होता है। क्या करने की आवश्यकता है कि write! को सरल मामलों में write_fmt write! को छोड़ देना चाहिए जहां स्वरूपण मशीनरी की आवश्यकता नहीं है, या स्पष्ट तेज़ पथ के मामले में स्वरूपण मशीनरी स्वयं बहुत तेज़ होनी चाहिए।

workingjubilee 8 सित॰ 2020

क्या यह पृष्ठ उपयोगी था?

0 / 5 - 0 रेटिंग्स

Rust: write!(wr,"foo") wr.write("foo.as_bytes()) की तुलना में 10% से 72% धीमी है।

सभी 9 टिप्पणियाँ

संबंधित मुद्दों