Potraga za optimizacijom

[ NrmMyth @ 09.08.2006. 07:12 ] @

Znte li koji kompajleri vrse ovu optimizaciju

Code:
string func( int i ) {...};

int main( void )
{
    string str;
    str = func( 13 );
    return 0;
}

Code:
void func( int i, string& __ret ) {...};

int main( void )
{
    string str;
    func( 13, str );
    return 0;
}

Hvala.

[ NastyBoy @ 09.08.2006. 09:11 ] @

To je "named return value optimization" - eliminacija copy konstruktora i destruktora za temporary objekte. VC++ 2005 implementira tu optimizaciju:

http://msdn.microsoft.com/libr...-us/dnvs05/html/nrvo_cpp05.asp

[ tosa @ 09.08.2006. 09:18 ] @

To što tebi treba je RVO (return value optimization), koju podržava MSVC a verovatno još
kompajlera, čini mi se i GCC. Problem je što ta optimizacija neće uvek raditi, evo primera:

Code:

Vector getVec( float X, float Y, float Z )
{
Vector ret(X,Y,Z);
return ret;
}

U ovom slučaju, kompajler neće uraditi ništa, dok će u sledećem potpuno eleminisati copy-constructor:

Code:

Vector getVec( float X, float Y, float Z )
{
return Vector(X,Y,Z);
}

[ Dragi Tata @ 09.08.2006. 12:19 ] @

Pisao sam nešto malo o tome svojevremeno:

http://www.novetehnologije.com/Default.aspx?tabid=87

[ kiklop74 @ 09.08.2006. 12:55 ] @

Sta kaze o tome Stann Lippman:

"The Name Return Value Optimization"
http://blogs.msdn.com/slippman/archive/2004/02/03/66739.aspx

[ NrmMyth @ 09.08.2006. 23:52 ] @

Vidim da tu postoje problemi.
Dali postoje smjernice kako konstruirati kod tako da se sigurno moze kazati da je NRVO uspjeo.

[ kiklop74 @ 10.08.2006. 12:51 ] @

Koliko ja znam ne postoji. Jedini nacin da se to sazna je analiza asemblerskog koda po kompajliranju ili uraditi nesto slicno kao u textu S. Lippmana.

Kad god mozes bolje koristi Return Value Optimization. To provereno radi.

Na primer:

Code:

#include <iostream>
#include <tchar.h>

struct nrvo_test {
    nrvo_test():someValue(0) {
        std::cout << "Default CTOR" << std::endl;
    }
    nrvo_test(int value) : someValue(value) {
        std::cout << "Standard CTOR" << std::endl;
    }
    nrvo_test(const nrvo_test &rhs) : someValue(rhs.someValue){
        std::cout << "Copy CTOR" << std::endl;
    }
    ~nrvo_test() {
        std::cout << "DTOR" << std::endl;
    }
    int GetValue() { return someValue; }
private:
    int someValue;
};

nrvo_test RVO(int value) {
    return nrvo_test(value); //ovako se pomaze kompajleru da uradi rvo optimizaciju
}                                    //dakle povratna vrednost se generise uz pomoc konstruktora
                                      //u povratnom delu funkcije

nrvo_test NRVO(int value) {
    nrvo_test val(value);
    return val;
}

int _tmain(int argc, _TCHAR* argv[])
{
    std::cout << RVO(10).GetValue() << std::endl;
    nrvo_test t = nrvo(20);
    std::cout << t.GetValue() << std::endl;
    return 0;
}

Videces kad iskompajliras ovaj program koliko puta je pozvan konstruktor i destruktor i po tome mozes da zakljucis da li je optimizacija izvrsena ili ne.

_{[Ovu poruku je menjao kiklop74 dana 10.08.2006. u 14:02 GMT+1]}

[ NrmMyth @ 10.08.2006. 19:43 ] @

Code:
nrvo_test RVO(int value) {
return nrvo_test(value); //ovako se pomaze kompajleru da uradi rvo optimizaciju
}

Znaci ovo bi trebalo uvijek raditi.

[ kiklop74 @ 10.08.2006. 20:38 ] @

Citat:

NrmMyth:

Code:
nrvo_test RVO(int value) {
return nrvo_test(value); //ovako se pomaze kompajleru da uradi rvo optimizaciju
}

Znaci ovo bi trebalo uvijek raditi.

Nema definitivnog odgovora na to pitanje. U vecini slucajeva verovatno da. Kao i sve drugo u programiranju sve zavisi od okolnosti kao i od tipa kompajlera, opcija za optimizaciju itd.