Optimize ediciyi bir tamsayı aralığı vererek ipucu verebilir miyim?

intBir değeri saklamak için bir tür kullanıyorum . Programın anlambilimiyle, değer her zaman çok küçük bir aralıkta değişir (0 - 36) ve int(a değil char) yalnızca CPU verimliliği nedeniyle kullanılır.

Bu kadar az sayıda tamsayı üzerinde birçok özel aritmetik optimizasyon yapılabiliyor gibi görünüyor. Bu tamsayılardaki birçok işlev çağrısı, küçük bir "büyülü" işlem kümesine optimize edilebilir ve hatta bazı işlevler tablo aramaları haline getirilebilir.

Peki, derleyiciye bunun inther zaman küçük aralıkta olduğunu söylemek mümkün mü ve derleyicinin bu optimizasyonları yapması mümkün mü?

Evet mümkün. Örneğin , derleyiciye imkansız koşullar hakkında bilgi vermek için gcckullanabilirsiniz __builtin_unreachable, örneğin:

if (value < 0 || value > 36) __builtin_unreachable();

Yukarıdaki koşulu bir makroda sarabiliriz:

#define assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)

Ve şu şekilde kullanın:

assume(x >= 0 && x <= 10);

Gördüğünüz gibi , gccbu bilgilere dayanarak optimizasyonları gerçekleştirir:

#define assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)

int func(int x){
    assume(x >=0 && x <= 10);

    if (x > 11){
        return 2;
    }
    else{
        return 17;
    }
}

üretir:

func(int):
    mov     eax, 17
    ret

Bununla birlikte, bir dezavantajı, kodunuz bu varsayımları ihlal ederse, tanımsız davranışlar elde etmenizdir .

Bu, hata ayıklama yapılarında bile size bildirilmez. Hatalarla varsayımları daha kolay hata ayıklamak / test etmek / yakalamak için, aşağıdakine benzer bir karma varsayım / onaylama makrosu (@David Z'ye yapılan krediler) kullanabilirsiniz:

#if defined(NDEBUG)
#define assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)
#else
#include <cassert>
#define assume(cond) assert(cond)
#endif

Ayıklama (yapılarınızı olarak NDEBUG değil tanımlanmıştır), sıradan bir gibi çalışır asserthata mesajı yazdırmak ve, abort'programını ing ve sürümde optimize kod üreten, bu bir varsayım kullanır inşa eder.

Bununla birlikte, normalin yerine geçmediğini unutmayın assert- condsürüm yapılarında kalır, bu yüzden böyle bir şey yapmamalısınız assume(VeryExpensiveComputation()).

Bunun için standart destek var. Yapmanız gereken, stdint.h( cstdint) öğesini dahil etmek ve ardından türü kullanmaktır uint_fast8_t.

Bu derleyiciye yalnızca 0 - 255 arasındaki sayıları kullandığınızı, ancak daha hızlı kod verirse daha büyük bir tür kullanmanın ücretsiz olduğunu bildirir. Benzer şekilde, derleyici değişkenin asla 255'in üzerinde bir değere sahip olmayacağını varsayabilir ve buna göre optimizasyonlar yapabilir.

Bildiğiniz zaman geçerli cevabı durum için iyidir kesin aralığı nedir, ama yine de doğru bir davranış istiyorsanız değeri, beklenen aralık dışında o zaman iş olmaz zaman.

Bu durumda, bu tekniğin işe yarayabileceğini buldum:

if (x == c)  // assume c is a constant
{
    foo(x);
}
else
{
    foo(x);
}

Fikir bir kod verisi dengesidir: 1 bit veriyi (olsun x == c) kontrol mantığına taşıyorsunuz .
Bu x, aslında bilinen bir sabit olan optimize ediciyi ima eder ve conu foo, muhtemelen oldukça ağır bir şekilde diğerlerinden ayrı olarak ilk çağrıyı satır içi ve optimize etmeye teşvik eder .

fooYine de kodu tek bir alt programa kattığınızdan emin olun - kodu çoğaltmayın.

Misal:

Bu tekniğin çalışması için biraz şanslı olmanız gerekir - derleyicinin şeyleri statik olarak değerlendirmemeye karar verdiği durumlar vardır ve bunlar keyfidir. Ancak işe yaradığında, iyi çalışır:

#include <math.h>
#include <stdio.h>

unsigned foo(unsigned x)
{
    return x * (x + 1);
}

unsigned bar(unsigned x) { return foo(x + 1) + foo(2 * x); }

int main()
{
    unsigned x;
    scanf("%u", &x);
    unsigned r;
    if (x == 1)
    {
        r = bar(bar(x));
    }
    else if (x == 0)
    {
        r = bar(bar(x));
    }
    else
    {
        r = bar(x + 1);
    }
    printf("%#x\n", r);
}

Sadece kullanmak -O3ve önceden değerlendirilerek sabitleri fark 0x20ve 0x30ede montajcı çıkışı .

Ben sadece daha standart C ++ olan bir çözüm istiyorsanız [[noreturn]], kendi yazmak için özniteliği kullanabilirsiniz söylemek için yunuslama unreachable.

Bu yüzden göstermek için mükemmel bir örnek deniss :

namespace detail {
    [[noreturn]] void unreachable(){}
}

#define assume(cond) do { if (!(cond)) detail::unreachable(); } while (0)

int func(int x){
    assume(x >=0 && x <= 10);

    if (x > 11){
        return 2;
    }
    else{
        return 17;
    }
}

Hangi gördüğünüz gibi , hemen hemen aynı kodu sonuçları:

detail::unreachable():
        rep ret
func(int):
        movl    $17, %eax
        ret

Dezavantajı elbette, bir [[noreturn]]fonksiyonun gerçekten döndüğüne dair bir uyarı almanızdır.