GCC neden bu döngüde std :: vector :: boyutunun değişmeyeceğini varsayamıyor?

if (i < input.size() - 1) print(0);Bu döngüde optimize edilecek bir iş arkadaşına iddia ettim, böylece input.size()her yinelemede okunmaz, ancak durum böyle değil!

void print(int x) {
    std::cout << x << std::endl;
}

void print_list(const std::vector<int>& input) {
    int i = 0;
    for (size_t i = 0; i < input.size(); i++) {
        print(input[i]);
        if (i < input.size() - 1) print(0);
    }
}

Gcc seçeneklerine sahip Derleyici Gezgini'ne göre -O3 -fno-exceptionsaslında input.size()her bir yinelemeyi okuyor ve leaçıkarma yapmak için kullanıyoruz !

        movq    0(%rbp), %rdx
        movq    8(%rbp), %rax
        subq    %rdx, %rax
        sarq    $2, %rax
        leaq    -1(%rax), %rcx
        cmpq    %rbx, %rcx
        ja      .L35
        addq    $1, %rbx

İlginçtir, Rust'ta bu optimizasyon gerçekleşir. Her yinelemede azaltılmış ibir değişkenle değiştirilmiş gibi görünüyor jve test i < input.size() - 1gibi bir şeyle değiştiriliyor j > 0.

fn print(x: i32) {
    println!("{}", x);
}

pub fn print_list(xs: &Vec<i32>) {
    for (i, x) in xs.iter().enumerate() {
        print(*x);
        if i < xs.len() - 1 {
            print(0);
        }
    }
}

In Derleyici Explorer ilgili montaj şuna benzer:

        cmpq    %r12, %rbx
        jae     .LBB0_4

Kontrol ettim ve ben eminim r12olduğunu xs.len() - 1ve rbxsayaç olduğunu. Daha önce bir addfor rbxve bir movdış döngü vardır r12.

Bu neden? Görünüşe göre GCC satır içi yapabiliyorsa size()ve operator[]olduğu gibi, bunun size()değişmediğini de bilmeli . Ama belki GCC'nin optimize edici, onu bir değişkene çekmeye değmeyeceğine karar verir? Ya da belki de bunu güvensiz hale getirecek başka bir olası yan etkisi vardır - kimse biliyor mu?

Satır içi olmayan işlev çağrısı cout.operator<<(int), iyileştirici için kara bir kutudur (çünkü kütüphane sadece C ++ ile yazılmıştır ve tüm iyileştirici bir prototiptir; yorumlarda tartışmaya bakın). Küresel bir değişkenin işaret edebileceği herhangi bir hafızanın değiştirildiğini varsaymak zorundadır.

(Ya da std::endlçağrı. BTW, neden sadece a basmak yerine o noktadan bir sifonu zorla '\n'?)

Örneğin , bildiği her şey için, std::vector<int> &inputbir global değişkene bir referanstır ve bu işlev çağrılarından biri, global var . (Ya da bir vector<int> *ptryerde bir küresel var, ya da static vector<int>başka bir derleme birimindeki bir işaretçiyi döndüren bir işlev ya da bir işlev bizim tarafımızdan bir referans geçirilmeden bu vektöre bir referans alabilir.

Eğer Adresinde alınmış hiç bir yerel değişken olsaydı, derleyici olabilir olmayan satır içi işlev çağrıları bunu mutasyona olamayacağını varsayalım. Çünkü herhangi bir global değişkenin bu nesneye bir işaretçi tutması mümkün olmazdı. ( Buna Kaçış Analizi denir ). Bu nedenle derleyici size_t iişlev çağrıları boyunca bir kayıtta tutabilir . ( int igölgelendirildiği size_t ive başka şekilde kullanılmadığı için optimize edilebilir ).

Aynı işlemi bir yerel ile de yapabilir vector(yani, taban, bitiş_boyutu ve bitiş_kapaklığı işaretçileri için.)

ISO C99 bu soruna bir çözüm vardır: int *restrict foo. Birçok C ++ derlenir destek int *__restrict foobellek tarafından işaret söz için fooolan sadece bu işaretçi aracılığıyla erişilebilir. En çok 2 diziyi alan işlevlerde kullanışlıdır ve derleyicinin çakışmayacağına dair söz vermek istersiniz. Böylece, bunu kontrol etmek ve bir geri dönüş döngüsü çalıştırmak için kod oluşturmadan otomatik vektörleştirebilir.

OP yorumları:

Rust'ta değiştirilemez bir referans, başka hiç kimsenin referansınız olan değeri mutasyona uğratmadığına dair küresel bir garantidir (C ++ 'a eşdeğer restrict)

Bu Rust'un neden bu optimizasyonu yapabileceğini ama C ++ yapamayacağını açıklıyor.

C ++ cihazınızı optimize etme

Açıkçası auto size = input.size();, fonksiyonunuzun üst kısmında bir kez kullanmalısınız , böylece derleyici bunun bir döngü değişmez olduğunu bilir. C ++ uygulamaları sizin için bu sorunu çözmez, bu yüzden kendiniz yapmanız gerekir.

Ayrıca const int *data = input.data();veri işaretçisi yüklerini de std::vector<int>"kontrol bloğundan" kaldırmanız gerekebilir . Optimizasyonun çok deyimsel olmayan kaynak değişiklikleri gerektirmesi talihsiz bir durumdur.

Rust, derleyici geliştiricilerinin derleyiciler için pratikte neyin mümkün olduğunu öğrendikten sonra tasarlanan çok daha modern bir dildir. CPU'ların yapabileceği bazı harika şeyleri portatif olarak açığa çıkarmak i32.count_ones, döndürmek, bit taraması vb. Dahil olmak üzere gerçekten başka şekillerde de gösterir std::bitset::count().