Evitando ramificazione in base al valore di ritorno della funzione che è un argomento di template

Question

Supponiamo le seguenti classi politiche che si prendono cura di un aspetto di un algoritmo:

struct VoidF { 
    static void f() { 
     ... // some code that has side effects 
    } 
}; 

struct BoolF { 
    static bool f() { 
     bool res = ...; // some computation 
     return res; 
    } 
}; 

La politica BoolF è "la valorizzazione-aware": quando BoolF :: f() restituisce true, l'algoritmo può uscire. VoidF è "enhancement-inconsapevole", quindi restituisce void (non voglio forzare l'utente della mia libreria a restituire bool quando non significa niente per lui).

L'algoritmo è attualmente scritto in questo modo:

template <typename F> 
struct Algorithm { 
    void run() { 
     ... // some computation here 

     if (std::is_same<decltype(F::f()), bool>::value) { 
      if (F::f()) return; 
     } else 
      F::f(); // If F is VoidF, there should be no branching and some 
        // compiler optimizations will be enabled 

     ... // more computation, unless F::f() got rid of it 
    } 
}; 

Naturalmente, questo non funziona se Algorithm è istanziato con VoidF. C'è un modo per risolvere questo in modo che non ci dovrebbero essere ramificazioni in Algorithm<VoidF>::run() come indicato dal commento?

Answer 1

È necessario utilizzare SFINAE anziché la ramificazione in fase di esecuzione.

si funzione run dovrebbe essere simile a questo:

template <typename F> 
struct Algorithm { 

    void run() { 
     ... // some computation here 

     doRun(); 
    } 

    template<std::enable_if_t<std::is_same<decltype(F::f()), bool>::value, int> = 0> 
    void doRun() { 
     if (F::f()) { 
      // do some more computations if needed or simply remove the if and return 
     } 
    } 

    template<std::enable_if_t<!std::is_same<decltype(F::f()), bool>::value, int> = 0> 
    void doRun() { 
     F::f(); 

     ... // more computation, unless F::f() got rid of it 
    } 
}; 

Answer 2

Una variante di answer Guillaume Racicot:

template <typename F> 
struct Algorithm { 

    void run() { 
     ... // some computation here 

     if(doRun()) 
      return; 

     ... // more computation, unless F::f() got rid of it 
    } 

    template<std::enable_if_t<std::is_same<decltype(F::f()), bool>::value, int> = 0> 
    bool doRun() { 
     return F::f(); 
    } 

    template<std::enable_if_t<!std::is_same<decltype(F::f()), bool>::value, int> = 0> 
    bool doRun() { 
     F::f(); 
     return false; 
    } 
}; 

Il tipo di F è noto al momento della compilazione. Quindi nel caso di VoidF il compilatore sa che doRun restituirà sempre false e quindi dovrebbe rimuovere tutto il codice di diramazione durante l'ottimizzazione.

Aggiornamento: Quindi non è garantito che non ci sarà alcuna filiale. Ma dovrebbe essere un caso piuttosto facile per l'ottimizzatore.

Answer 3

Ecco il mio tentativo di farlo senza SFINAE:

template <typename F> 
struct Algorithm { 
    void run() { 
     ... // some computation here 

     myRun(std::integral_constant< 
       bool, std::is_same<decltype(F::f()), bool>::value>()); 
    } 

private: 
    void myRun(std::true_type) { 
     if (F::f()) return; 
     moreComputation(); 
    } 

    void myRun(std::false_type) { 
     F::f(); 
     moreComputation(); 
    } 

    void moreComputation() { ... } 
};