ฟังก์ชันและประสิทธิภาพเสมือนจริง - C ++

ในการออกแบบชั้นเรียนของฉันฉันใช้คลาสนามธรรมและฟังก์ชันเสมือนอย่างกว้างขวาง ฉันรู้สึกว่าฟังก์ชันเสมือนมีผลต่อประสิทธิภาพ นี่คือเรื่องจริง? แต่ฉันคิดว่าความแตกต่างของประสิทธิภาพนี้ไม่สามารถสังเกตเห็นได้และดูเหมือนว่าฉันกำลังทำการเพิ่มประสิทธิภาพก่อนกำหนด ขวา?

หลักการง่ายๆคือ:

ไม่ใช่ปัญหาด้านประสิทธิภาพจนกว่าคุณจะพิสูจน์ได้

การใช้ฟังก์ชันเสมือนจะมีผลเล็กน้อยต่อประสิทธิภาพการทำงาน แต่ไม่น่าจะส่งผลกระทบต่อประสิทธิภาพโดยรวมของแอปพลิเคชันของคุณ สถานที่ที่ดีกว่าในการค้นหาการปรับปรุงประสิทธิภาพอยู่ในอัลกอริทึมและ I / O

บทความที่ดีที่พูดคุยเกี่ยวกับฟังก์ชั่นเสมือนจริง (และอื่น ๆ ) เป็นสมาชิกตัวชี้ฟังก์ชั่นและเร็วที่สุดที่เป็นไปได้ c ++ ผู้ได้รับมอบหมาย

คำถามของคุณทำให้ฉันสงสัยมากดังนั้นฉันจึงดำเนินการกำหนดเวลาบางอย่างบน CPU PowerPC ตามลำดับ 3GHz ที่เราใช้งานได้ การทดสอบที่ฉันใช้คือการสร้างคลาสเวกเตอร์ 4d อย่างง่ายพร้อมฟังก์ชัน get / set

class TestVec 
{
    float x,y,z,w; 
public:
    float GetX() { return x; }
    float SetX(float to) { return x=to; }  // and so on for the other three 
}

จากนั้นฉันตั้งค่าอาร์เรย์สามอาร์เรย์โดยแต่ละอาร์เรย์มี 1024 เวกเตอร์เหล่านี้ (เล็กพอที่จะใส่ L1 ได้) และเรียกใช้ลูปที่เพิ่มเข้าด้วยกัน (Ax = Bx + Cx) 1,000 ครั้ง ฉันวิ่งนี้กับฟังก์ชั่นที่กำหนดไว้เป็นinline, virtualและฟังก์ชั่นการโทรปกติ นี่คือผลลัพธ์:

• อินไลน์: 8ms (0.65ns ต่อการโทร)
• โดยตรง: 68ms (5.53ns ต่อการโทร)
• เสมือน: 160ms (13ns ต่อการโทร)

ดังนั้นในกรณีนี้ (ที่ทุกอย่างพอดีกับแคช) การเรียกฟังก์ชันเสมือนช้ากว่าการโทรแบบอินไลน์ประมาณ 20 เท่า แต่สิ่งนี้หมายความว่าอย่างไร? การเดินทางผ่านลูปแต่ละครั้งทำให้เกิด3 * 4 * 1024 = 12,288การเรียกใช้ฟังก์ชัน (เวกเตอร์ 1024 คูณสี่องค์ประกอบคูณสามการเรียกต่อการเพิ่ม) ดังนั้นเวลาเหล่านี้จึงแสดงถึง1000 * 12,288 = 12,288,000การเรียกใช้ฟังก์ชัน ลูปเสมือนใช้เวลานานกว่าลูปโดยตรง 92 มิลลิวินาทีดังนั้นค่าใช้จ่ายเพิ่มเติมต่อการโทรคือ 7 นาโนวินาทีต่อฟังก์ชัน

จากนี้ฉันสรุปได้ว่าใช่ฟังก์ชันเสมือนจริงช้ากว่าฟังก์ชันโดยตรงมากและไม่เว้นแต่คุณจะวางแผนที่จะโทรหาพวกเขาสิบล้านครั้งต่อวินาทีก็ไม่สำคัญ

ดูเพิ่มเติม: การเปรียบเทียบชุดประกอบที่สร้างขึ้น

เมื่อ Objective-C (โดยที่วิธีการทั้งหมดเป็นเสมือน) เป็นภาษาหลักสำหรับ iPhone และJavaของ freakin เป็นภาษาหลักสำหรับ Android ฉันคิดว่ามันค่อนข้างปลอดภัยที่จะใช้ฟังก์ชันเสมือน C ++ บนเสาดูอัลคอร์ 3 GHz ของเรา

ในแอปพลิเคชันที่มีประสิทธิภาพสูงมาก (เช่นวิดีโอเกม) การเรียกใช้ฟังก์ชันเสมือนอาจช้าเกินไป ด้วยฮาร์ดแวร์ที่ทันสมัยปัญหาด้านประสิทธิภาพที่ใหญ่ที่สุดคือการพลาดแคช หากข้อมูลไม่อยู่ในแคชอาจต้องใช้เวลาหลายร้อยรอบก่อนที่จะพร้อมใช้งาน

การเรียกใช้ฟังก์ชันปกติสามารถสร้างแคชคำสั่งพลาดเมื่อ CPU ดึงคำสั่งแรกของฟังก์ชันใหม่และไม่ได้อยู่ในแคช

การเรียกใช้ฟังก์ชันเสมือนก่อนอื่นต้องโหลดตัวชี้ vtable จากออบเจ็กต์ ซึ่งอาจส่งผลให้พลาดแคชข้อมูล จากนั้นโหลดตัวชี้ฟังก์ชันจาก vtable ซึ่งอาจส่งผลให้แคชข้อมูลอื่นพลาด จากนั้นจะเรียกใช้ฟังก์ชันซึ่งอาจส่งผลให้แคชคำสั่งพลาดเหมือนฟังก์ชันที่ไม่ใช่ฟังก์ชันเสมือน

ในหลาย ๆ กรณีการพลาดแคชพิเศษสองรายการไม่ใช่เรื่องที่น่ากังวล แต่ในการทำงานร่วมกันอย่างแน่นหนากับโค้ดที่สำคัญด้านประสิทธิภาพสามารถลดประสิทธิภาพลงได้อย่างมาก

จากหน้า 44 ของคู่มือ "Optimizing Software in C ++"ของAgner Fog :

เวลาที่ใช้ในการเรียกฟังก์ชันสมาชิกเสมือนคือรอบนาฬิกาสองสามรอบมากกว่าที่จะเรียกฟังก์ชันสมาชิกที่ไม่ใช่เสมือนโดยที่คำสั่งเรียกฟังก์ชันจะเรียกฟังก์ชันเสมือนเวอร์ชันเดียวกันเสมอ หากเวอร์ชันมีการเปลี่ยนแปลงคุณจะได้รับการคาดคะเนผิด 10 - 30 รอบนาฬิกา กฎสำหรับการคาดคะเนและการคาดเดาผิดของการเรียกฟังก์ชันเสมือนเหมือนกับคำสั่ง switch ...

อย่างแน่นอน มันเป็นปัญหาในทางกลับกันเมื่อคอมพิวเตอร์ทำงานที่ 100Mhz เนื่องจากการเรียกเมธอดทุกครั้งต้องมีการค้นหาบน vtable ก่อนที่จะถูกเรียก แต่วันนี้ .. บนซีพียู 3Ghz ที่มีแคชระดับ 1 พร้อมหน่วยความจำมากกว่าคอมพิวเตอร์เครื่องแรกของฉัน? ไม่ใช่เลย. การจัดสรรหน่วยความจำจากแรมหลักจะทำให้คุณเสียเวลามากกว่าถ้าฟังก์ชันทั้งหมดของคุณเป็นเสมือนจริง

มันเหมือนกับสมัยก่อนที่ผู้คนกล่าวว่าการเขียนโปรแกรมแบบมีโครงสร้างนั้นช้าเพราะโค้ดทั้งหมดถูกแบ่งออกเป็นฟังก์ชันแต่ละฟังก์ชันต้องการการจัดสรรสแต็กและการเรียกใช้ฟังก์ชัน!

ครั้งเดียวที่ฉันคิดว่าจะต้องคำนึงถึงผลกระทบด้านประสิทธิภาพของฟังก์ชันเสมือนจริงคือถ้ามีการใช้งานอย่างหนักและสร้างอินสแตนซ์ในโค้ดเทมเพลตที่ลงเอยด้วยทุกสิ่ง ถึงอย่างนั้นฉันก็จะไม่ใช้ความพยายามมากเกินไป!

ป.ล. นึกถึงภาษาอื่น ๆ ที่ 'ใช้งานง่าย' - วิธีการทั้งหมดของพวกเขาเป็นเสมือนจริงภายใต้ฝาครอบและไม่ได้รวบรวมข้อมูลในปัจจุบัน

มีเกณฑ์ประสิทธิภาพอื่นนอกเหนือจากเวลาดำเนินการ Vtable ใช้พื้นที่หน่วยความจำเช่นกันและในบางกรณีสามารถหลีกเลี่ยงได้: ATL ใช้ " การเชื่อมโยงไดนามิกจำลอง " เวลาคอมไพล์กับเทมเพลตเพื่อให้ได้ผลของ "ความแตกต่างแบบคงที่" ซึ่งเป็นเรื่องยากที่จะอธิบาย โดยพื้นฐานแล้วคุณจะส่งคลาสที่ได้รับมาเป็นพารามิเตอร์ไปยังเทมเพลตคลาสพื้นฐานดังนั้นในเวลาคอมไพล์คลาสพื้นฐานจะ "รู้" ว่าคลาสที่ได้รับมาคืออะไรในแต่ละอินสแตนซ์ จะไม่อนุญาตให้คุณเก็บคลาสที่ได้รับมาหลายแบบในคอลเลกชันของประเภทพื้นฐาน (นั่นคือความหลากหลายแบบรันไทม์) แต่จากความรู้สึกคงที่ถ้าคุณต้องการสร้างคลาส Y ที่เหมือนกับคลาส X ที่มีอยู่ก่อนหน้าซึ่งมี hooks สำหรับการลบล้างประเภทนี้คุณเพียงแค่ต้องแทนที่วิธีการที่คุณสนใจจากนั้นคุณจะได้รับเมธอดพื้นฐานของคลาส X โดยไม่ต้องมี vtable

ในคลาสที่มีหน่วยความจำขนาดใหญ่ค่าใช้จ่ายของตัวชี้ vtable เพียงตัวเดียวนั้นไม่มากนัก แต่คลาส ATL บางตัวใน COM นั้นมีขนาดเล็กมากและคุ้มค่ากับการประหยัด vtable หากกรณีความหลากหลายแบบรันไทม์จะไม่เกิดขึ้น

ดูคำถาม SO อื่น ๆ นี้ด้วย

นี่คือโพสต์ที่ฉันพบว่าพูดถึงด้านประสิทธิภาพเวลา CPU

ใช่คุณพูดถูกและถ้าคุณอยากรู้เกี่ยวกับค่าใช้จ่ายในการเรียกฟังก์ชันเสมือนจริงคุณอาจพบว่าโพสต์นี้น่าสนใจ

วิธีเดียวที่ฉันจะเห็นว่าฟังก์ชันเสมือนจะกลายเป็นปัญหาด้านประสิทธิภาพคือถ้าฟังก์ชันเสมือนจำนวนมากถูกเรียกใช้ภายในลูปที่รัดกุมและในกรณีที่ทำให้เกิดข้อผิดพลาดของเพจหรือการดำเนินการหน่วยความจำ "หนัก" อื่น ๆ

แม้ว่าคนอื่น ๆ จะบอกว่ามันไม่เคยเป็นปัญหาสำหรับคุณในชีวิตจริง และถ้าคุณคิดว่าเป็นเช่นนั้นให้เรียกใช้ผู้สร้างโปรไฟล์ทำการทดสอบและตรวจสอบว่าปัญหานี้เป็นปัญหาจริงหรือไม่ก่อนที่จะพยายาม "ไม่ออกแบบ" โค้ดของคุณเพื่อประโยชน์ด้านประสิทธิภาพ

เมื่อเมธอดคลาสไม่ใช่เสมือนคอมไพเลอร์มักจะทำซับใน ในทางตรงกันข้ามเมื่อคุณใช้พอยน์เตอร์ไปยังคลาสบางคลาสที่มีฟังก์ชันเสมือนจริงแอดเดรสจริงจะทราบเฉพาะในรันไทม์เท่านั้น

นี่เป็นตัวอย่างที่ดีจากการทดสอบความแตกต่างของเวลา ~ 700% (!):

#include <time.h>

class Direct
{
public:
    int Perform(int &ia) { return ++ia; }
};

class AbstrBase
{
public:
    virtual int Perform(int &ia)=0;
};

class Derived: public AbstrBase
{
public:
    virtual int Perform(int &ia) { return ++ia; }
};


int main(int argc, char* argv[])
{
    Direct *pdir, dir;
    pdir = &dir;

    int ia=0;
    double start = clock();
    while( pdir->Perform(ia) );
    double end = clock();
    printf( "Direct %.3f, ia=%d\n", (end-start)/CLOCKS_PER_SEC, ia );

    Derived drv;
    AbstrBase *ab = &drv;

    ia=0;
    start = clock();
    while( ab->Perform(ia) );
    end = clock();
    printf( "Virtual: %.3f, ia=%d\n", (end-start)/CLOCKS_PER_SEC, ia );

    return 0;
}

ผลกระทบของการเรียกฟังก์ชันเสมือนขึ้นอยู่กับสถานการณ์ หากมีการโทรไม่กี่ครั้งและปริมาณงานที่สำคัญในฟังก์ชันอาจเป็นเรื่องเล็กน้อย

หรือเมื่อเป็นการโทรเสมือนที่ใช้ซ้ำ ๆ หลาย ๆ ครั้งในขณะที่ดำเนินการง่ายๆบางอย่าง - อาจเป็นเรื่องใหญ่มาก

ฉันกลับไปกลับมาอย่างน้อย 20 ครั้งในโครงการเฉพาะของฉัน แม้ว่าจะมีสามารถเป็นบางส่วนกำไรที่ดีในแง่ของการใช้ซ้ำรหัสความชัดเจนการบำรุงรักษาและการอ่านบนมืออื่น ๆ ที่ฮิตประสิทธิภาพการทำงานยังคงทำมีอยู่กับการทำงานเสมือนจริง

ประสิทธิภาพที่โดดเด่นจะเห็นได้ชัดบนแล็ปท็อป / เดสก์ท็อป / แท็บเล็ตสมัยใหม่หรือไม่ ... อาจจะไม่! อย่างไรก็ตามในบางกรณีที่มีระบบฝังตัวการตีประสิทธิภาพอาจเป็นปัจจัยผลักดันให้โค้ดของคุณไม่มีประสิทธิภาพโดยเฉพาะอย่างยิ่งถ้าฟังก์ชันเสมือนถูกเรียกซ้ำแล้วซ้ำอีกในการวนซ้ำ

นี่คือเอกสารฉบับหนึ่งที่วิเคราะห์แนวทางปฏิบัติที่ดีที่สุดสำหรับ C / C ++ ในบริบทระบบฝังตัว: http://www.open-std.org/jtc1/sc22/wg21/docs/ESC_Boston_01_304_paper.pdf

สรุป: ขึ้นอยู่กับโปรแกรมเมอร์ที่จะเข้าใจข้อดี / ข้อเสียของการใช้โครงสร้างบางอย่างกับโครงสร้างอื่น หากคุณไม่ได้รับการขับเคลื่อนด้วยประสิทธิภาพขั้นสูงคุณอาจไม่สนใจเกี่ยวกับประสิทธิภาพที่ยอดเยี่ยมและควรใช้ OO ที่เป็นระเบียบทั้งหมดใน C ++ เพื่อช่วยให้โค้ดของคุณใช้งานได้มากที่สุด

จากประสบการณ์ของฉันสิ่งที่เกี่ยวข้องหลักคือความสามารถในการแทรกฟังก์ชัน หากคุณมีความต้องการด้านประสิทธิภาพ / การปรับให้เหมาะสมซึ่งกำหนดให้ฟังก์ชันต้องมีอินไลน์คุณจะไม่สามารถทำให้ฟังก์ชันเสมือนจริงได้เนื่องจากจะป้องกันไม่ให้สิ่งนั้น มิฉะนั้นคุณอาจไม่สังเกตเห็นความแตกต่าง

สิ่งหนึ่งที่ควรทราบคือ:

boolean contains(A element) {
    for (A current: this)
        if (element.equals(current))
            return true;
    return false;
}

อาจเร็วกว่านี้:

boolean contains(A element) {
    for (A current: this)
        if (current.equals(equals))
            return true;
    return false;
}

เนื่องจากวิธีแรกเรียกใช้ฟังก์ชันเดียวเท่านั้นในขณะที่วิธีที่สองอาจเรียกใช้ฟังก์ชันต่างๆมากมาย สิ่งนี้ใช้กับฟังก์ชันเสมือนจริงในภาษาใดก็ได้

ฉันพูดว่า "อาจ" เพราะขึ้นอยู่กับคอมไพเลอร์แคช ฯลฯ

การลงโทษด้านประสิทธิภาพของการใช้ฟังก์ชันเสมือนจริงไม่สามารถมีน้ำหนักเกินข้อได้เปรียบที่คุณได้รับในระดับการออกแบบ สมมติว่าการเรียกใช้ฟังก์ชันเสมือนจะมีประสิทธิภาพน้อยลง 25% จากนั้นจึงเรียกโดยตรงไปยังฟังก์ชันคงที่ เนื่องจากมีระดับการเหนี่ยวนำผ่าน VMT อย่างไรก็ตามเวลาที่ใช้ในการโทรโดยปกติจะน้อยมากเมื่อเทียบกับเวลาที่ใช้ในการเรียกใช้ฟังก์ชันของคุณจริงดังนั้นค่าใช้จ่ายด้านประสิทธิภาพโดยรวมจะไม่เหมาะสมโดยเฉพาะอย่างยิ่งกับประสิทธิภาพของฮาร์ดแวร์ในปัจจุบัน นอกจากนี้บางครั้งคอมไพเลอร์ยังสามารถปรับให้เหมาะสมและเห็นว่าไม่จำเป็นต้องมีการโทรเสมือนและรวบรวมเป็นการโทรแบบคงที่ ดังนั้นอย่ากังวลใช้ฟังก์ชันเสมือนจริงและคลาสนามธรรมให้มากที่สุดเท่าที่คุณต้องการ

ฉันมักจะตั้งคำถามกับตัวเองในเรื่องนี้โดยเฉพาะอย่างยิ่งตั้งแต่เมื่อไม่กี่ปีที่ผ่านมาฉันได้ทำการทดสอบดังกล่าวเปรียบเทียบการกำหนดเวลาของการโทรแบบสมาชิกมาตรฐานกับการโทรเสมือนจริงและรู้สึกโกรธมากเกี่ยวกับผลลัพธ์ในเวลานั้นโดยมีการโทรเสมือนว่างเปล่า ช้ากว่าแบบไม่เสมือน 8 เท่า

วันนี้ฉันต้องตัดสินใจว่าจะใช้ฟังก์ชันเสมือนในการจัดสรรหน่วยความจำเพิ่มเติมในคลาสบัฟเฟอร์ของฉันหรือไม่ในแอปที่มีประสิทธิภาพมากฉันจึง googled (และพบคุณ) และในที่สุดก็ทำการทดสอบอีกครั้ง

// g++ -std=c++0x -o perf perf.cpp -lrt
#include <typeinfo>    // typeid
#include <cstdio>      // printf
#include <cstdlib>     // atoll
#include <ctime>       // clock_gettime

struct Virtual { virtual int call() { return 42; } }; 
struct Inline { inline int call() { return 42; } }; 
struct Normal { int call(); };
int Normal::call() { return 42; }

template<typename T>
void test(unsigned long long count) {
    std::printf("Timing function calls of '%s' %llu times ...\n", typeid(T).name(), count);

    timespec t0, t1;
    clock_gettime(CLOCK_REALTIME, &t0);

    T test;
    while (count--) test.call();

    clock_gettime(CLOCK_REALTIME, &t1);
    t1.tv_sec -= t0.tv_sec;
    t1.tv_nsec = t1.tv_nsec > t0.tv_nsec
        ? t1.tv_nsec - t0.tv_nsec
        : 1000000000lu - t0.tv_nsec;

    std::printf(" -- result: %d sec %ld nsec\n", t1.tv_sec, t1.tv_nsec);
}

template<typename T, typename Ua, typename... Un>
void test(unsigned long long count) {
    test<T>(count);
    test<Ua, Un...>(count);
}

int main(int argc, const char* argv[]) {
    test<Inline, Normal, Virtual>(argc == 2 ? atoll(argv[1]) : 10000000000llu);
    return 0;
}

และรู้สึกประหลาดใจมากที่ในความเป็นจริงมันไม่สำคัญเลยอีกต่อไป แม้ว่ามันจะสมเหตุสมผลที่จะอินไลน์ได้เร็วกว่าที่ไม่ใช่เสมือนและมันเร็วกว่าเวอร์ชวล แต่ก็มักจะมาพร้อมกับการโหลดของคอมพิวเตอร์โดยรวมไม่ว่าแคชของคุณจะมีข้อมูลที่จำเป็นหรือไม่ก็ตามและในขณะที่คุณสามารถปรับให้เหมาะสมได้ ที่ระดับแคชฉันคิดว่าผู้พัฒนาคอมไพเลอร์ควรทำสิ่งนี้มากกว่าโดยนักพัฒนาแอปพลิเคชัน