C # vs C - ความแตกต่างของประสิทธิภาพที่ยิ่งใหญ่

ฉันพบความแตกต่างของประสิทธิภาพอย่างมากระหว่างโค้ดที่คล้ายกันใน C An C #

รหัส C คือ:

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

main()
{
    int i;
    double root;

    clock_t start = clock();
    for (i = 0 ; i <= 100000000; i++){
        root = sqrt(i);
    }
    printf("Time elapsed: %f\n", ((double)clock() - start) / CLOCKS_PER_SEC);   

}

และ C # (แอปคอนโซล) คือ:

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            DateTime startTime = DateTime.Now;
            double root;
            for (int i = 0; i <= 100000000; i++)
            {
                root = Math.Sqrt(i);
            }
            TimeSpan runTime = DateTime.Now - startTime;
            Console.WriteLine("Time elapsed: " + Convert.ToString(runTime.TotalMilliseconds/1000));
        }
    }
}

ด้วยรหัสข้างต้น C # จะเสร็จสมบูรณ์ใน 0.328125 วินาที (รุ่นวางจำหน่าย) และ C ใช้เวลา 11.14 วินาทีในการทำงาน

c กำลังถูกคอมไพล์ไปยัง windows ที่เรียกใช้งานได้โดยใช้ mingw

ฉันอยู่ภายใต้สมมติฐานเสมอว่า C / C ++ เร็วกว่าหรืออย่างน้อยก็เทียบได้กับ C # .net อะไรคือสาเหตุที่ทำให้ C ทำงานช้าลงกว่า 30 เท่า?

แก้ไข: ดูเหมือนว่าเครื่องมือเพิ่มประสิทธิภาพ C # กำลังลบรูทเนื่องจากไม่ได้ใช้งาน ฉันเปลี่ยนการกำหนดรูทเป็นรูท + = และพิมพ์ผลรวมในตอนท้าย ฉันยังรวบรวม C โดยใช้ cl.exe พร้อมกับตั้งค่าสถานะ / O2 สำหรับความเร็วสูงสุด

ผลลัพธ์ตอนนี้: 3.75 วินาทีสำหรับ C 2.61 วินาทีสำหรับ C #

C ยังคงใช้เวลานานกว่า แต่ก็ยอมรับได้

เนื่องจากคุณไม่เคยใช้ 'root' คอมไพลเลอร์อาจลบการโทรออกเพื่อปรับวิธีการของคุณให้เหมาะสม

คุณสามารถลองสะสมค่ารากที่สองลงในตัวสะสมพิมพ์ออกมาที่ส่วนท้ายของวิธีการและดูว่าเกิดอะไรขึ้น

แก้ไข: ดูคำตอบของ Jalfด้านล่าง

คุณต้องเปรียบเทียบบิวด์ดีบัก ฉันเพิ่งรวบรวมรหัส C ของคุณและได้รับ

Time elapsed: 0.000000

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

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

อย่างไรก็ตามคุณจะไม่ต้องปวดหัวมากในระยะยาวหากคุณละทิ้งความคิดที่ว่าภาษา "เร็ว" กว่าภาษาอื่น ๆ C # ไม่มีความเร็วมากกว่าภาษาอังกฤษ

มีบางสิ่งในภาษา C ที่จะมีประสิทธิภาพแม้ในคอมไพเลอร์ที่ไม่ได้ปรับแต่งที่ไร้เดียงสาและยังมีสิ่งอื่น ๆ ที่ต้องอาศัยคอมไพเลอร์เป็นอย่างมากในการปรับทุกอย่างให้เหมาะสม และแน่นอนเช่นเดียวกันกับ C # หรือภาษาอื่น ๆ

ความเร็วในการดำเนินการกำหนดโดย:

• แพลตฟอร์มที่คุณใช้งานอยู่ (ระบบปฏิบัติการฮาร์ดแวร์ซอฟต์แวร์อื่น ๆ ที่ทำงานบนระบบ)
• คอมไพเลอร์
• ซอร์สโค้ดของคุณ

คอมไพเลอร์ C # ที่ดีจะให้รหัสที่มีประสิทธิภาพ คอมไพเลอร์ C ที่ไม่ดีจะสร้างโค้ดช้า แล้วคอมไพเลอร์ C ที่สร้างรหัส C # ซึ่งคุณสามารถเรียกใช้ผ่านคอมไพเลอร์ C # ได้ล่ะ? จะวิ่งเร็วแค่ไหน? ภาษาไม่มีความเร็ว รหัสของคุณไม่

ฉันจะสรุปสั้น ๆ ว่ามีคำตอบแล้ว C # มีข้อได้เปรียบอย่างมากในการมีแบบจำลองจุดลอยตัวที่กำหนดไว้อย่างดี สิ่งนี้เกิดขึ้นเพื่อให้ตรงกับโหมดการทำงานดั้งเดิมของชุดคำสั่ง FPU และ SSE บนโปรเซสเซอร์ x86 และ x64 ไม่มีความบังเอิญที่นั่น JITter รวบรวม Math.Sqrt () เป็นคำสั่งแบบอินไลน์สองสามคำสั่ง

Native C / C ++ มีความเข้ากันได้ย้อนหลังเป็นเวลาหลายปี / fp: precision, / fp: fast และ / fp: ตัวเลือกการคอมไพล์ที่เข้มงวดจะมองเห็นได้มากที่สุด ดังนั้นจึงต้องเรียกใช้ฟังก์ชัน CRT ที่ใช้ sqrt () และตรวจสอบตัวเลือกทศนิยมที่เลือกเพื่อปรับผลลัพธ์ ช้าจัง

ฉันเป็น C ++ และนักพัฒนา C # ฉันได้พัฒนาแอปพลิเคชั่น C # ตั้งแต่เบต้าแรกของเฟรมเวิร์ก. NET และฉันมีประสบการณ์มากกว่า 20 ปีในการพัฒนาแอปพลิเคชัน C ++ ประการแรกรหัส C # จะไม่เร็วกว่าแอปพลิเคชัน C ++ แต่ฉันจะไม่พูดถึงการสนทนาที่ยาวนานเกี่ยวกับโค้ดที่มีการจัดการวิธีการทำงานเลเยอร์ระหว่างการทำงานการจัดการหน่วยความจำภายในระบบประเภทไดนามิกและตัวรวบรวมขยะ อย่างไรก็ตามให้ฉันดำเนินการต่อโดยบอกว่าเกณฑ์มาตรฐานที่ระบุไว้ที่นี่ทั้งหมดให้ผลลัพธ์ที่ไม่ถูกต้อง

ให้ฉันอธิบาย: สิ่งแรกที่เราต้องพิจารณาคือคอมไพเลอร์ JIT สำหรับ C # (.NET Framework 4) ตอนนี้ JIT สร้างโค้ดเนทีฟสำหรับ CPU โดยใช้อัลกอริธึมการเพิ่มประสิทธิภาพต่างๆ (ซึ่งมีแนวโน้มที่จะก้าวร้าวมากกว่าเครื่องมือเพิ่มประสิทธิภาพ C ++ เริ่มต้นที่มาพร้อมกับ Visual Studio) และชุดคำสั่งที่ใช้โดยคอมไพลเลอร์. NET JIT เป็นการสะท้อนที่ใกล้เคียงกับ CPU จริงมากขึ้น บนเครื่องดังนั้นการแทนที่บางอย่างในรหัสเครื่องสามารถทำได้เพื่อลดรอบนาฬิกาและปรับปรุงอัตราการตีในแคชไปป์ไลน์ของ CPU และสร้างการเพิ่มประสิทธิภาพไฮเปอร์เธรดเพิ่มเติมเช่นคำสั่งของเราในการจัดลำดับใหม่และการปรับปรุงที่เกี่ยวข้องกับการทำนายสาขา

สิ่งนี้หมายความว่าเว้นแต่คุณจะคอมไพล์แอปพลิเคชัน C ++ ของคุณโดยใช้พารามิเตอรที่ถูกต้องสำหรับรุ่น RELEASE (ไม่ใช่รุ่น DEBUG) แอปพลิเคชัน C ++ ของคุณอาจทำงานช้ากว่าแอปพลิเคชัน C # หรือ. NET ที่เกี่ยวข้อง เมื่อระบุคุณสมบัติโปรเจ็กต์บนแอปพลิเคชัน C ++ ของคุณตรวจสอบให้แน่ใจว่าคุณเปิดใช้งาน "การเพิ่มประสิทธิภาพเต็มรูปแบบ" และ "โปรดปรานโค้ดด่วน" หากคุณมีเครื่อง 64 บิตคุณต้องระบุเพื่อสร้าง x64 เป็นแพลตฟอร์มเป้าหมายมิฉะนั้นโค้ดของคุณจะถูกเรียกใช้ผ่านเลเยอร์ย่อยการแปลง (WOW64) ซึ่งจะลดประสิทธิภาพลงอย่างมาก

เมื่อคุณดำเนินการปรับแต่งที่ถูกต้องในคอมไพเลอร์ฉันจะได้รับ. 72 วินาทีสำหรับแอปพลิเคชัน C ++ และ 1.16 วินาทีสำหรับแอปพลิเคชัน C # (ทั้งในรุ่นรุ่น) เนื่องจากแอปพลิเคชัน C # เป็นแอปพลิเคชันพื้นฐานมากและจัดสรรหน่วยความจำที่ใช้ในการวนซ้ำบนสแต็กและไม่ได้อยู่บนฮีปจึงทำงานได้ดีกว่าแอปพลิเคชันจริงที่เกี่ยวข้องกับวัตถุการคำนวณที่หนักหน่วงและชุดข้อมูลขนาดใหญ่ ดังนั้นตัวเลขที่ให้จึงเป็นตัวเลขในแง่ดีที่เอนเอียงไปทาง C # และกรอบงาน. NET แม้จะมีอคตินี้ แต่แอปพลิเคชัน C ++ ก็ทำงานเสร็จในเวลาเพียงครึ่งเวลากว่าแอปพลิเคชัน C # ที่เทียบเท่า โปรดทราบว่าคอมไพเลอร์ Microsoft C ++ ที่ฉันใช้ไม่มีการเพิ่มประสิทธิภาพไปป์ไลน์และไฮเปอร์เธรดที่ถูกต้อง (โดยใช้ WinDBG เพื่อดูคำแนะนำในการประกอบ)

ตอนนี้ถ้าเราใช้คอมไพเลอร์ Intel (ซึ่งเป็นความลับของอุตสาหกรรมในการสร้างแอปพลิเคชันประสิทธิภาพสูงบนโปรเซสเซอร์ AMD / Intel) รหัสเดียวกันจะทำงานใน. 54 วินาทีสำหรับปฏิบัติการ C ++ เทียบกับ. 72 วินาทีโดยใช้ Microsoft Visual Studio 2010 ท้ายที่สุดผลลัพธ์สุดท้ายคือ. 54 วินาทีสำหรับ C ++ และ 1.16 วินาทีสำหรับ C # ดังนั้นโค้ดที่สร้างโดยคอมไพลเลอร์. NET JIT จึงใช้เวลานานกว่าไฟล์ปฏิบัติการ C ++ ถึง 214% เวลาส่วนใหญ่ที่ใช้ใน. 54 วินาทีคือการรับเวลาจากระบบและไม่ได้อยู่ในลูปนั่นเอง!

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

เมื่อวัดประสิทธิภาพของ C ++ และ. NET IL สิ่งสำคัญคือต้องดูรหัสแอสเซมบลีเพื่อให้แน่ใจว่ามีการคำนวณทั้งหมดอยู่ที่นั่น สิ่งที่ฉันพบคือการไม่ใส่โค้ดเพิ่มเติมใน C # โค้ดส่วนใหญ่ในตัวอย่างด้านบนจะถูกลบออกจากไบนารี นี่เป็นกรณีของ C ++ เช่นกันเมื่อคุณใช้เครื่องมือเพิ่มประสิทธิภาพเชิงรุกเช่นตัวที่มาพร้อมกับคอมไพเลอร์ Intel C ++ ผลลัพธ์ที่ฉันให้ไว้ข้างต้นถูกต้อง 100% และผ่านการตรวจสอบในระดับการประกอบ

ปัญหาหลักของฟอรัมจำนวนมากบนอินเทอร์เน็ตที่มีมือใหม่จำนวนมากฟังโฆษณาชวนเชื่อทางการตลาดของ Microsoft โดยไม่เข้าใจเทคโนโลยีและอ้างว่า C # เร็วกว่า C ++ ข้ออ้างคือตามทฤษฎีแล้ว C # เร็วกว่า C ++ เนื่องจากคอมไพเลอร์ JIT สามารถปรับโค้ดให้เหมาะสมกับ CPU ได้ ปัญหาของทฤษฎีนี้คือมีท่อประปาจำนวนมากที่มีอยู่ในกรอบงาน. NET ที่ทำให้ประสิทธิภาพการทำงานช้าลง ท่อประปาที่ไม่มีในแอปพลิเคชัน C ++ นอกจากนี้นักพัฒนาที่มีประสบการณ์จะรู้จักคอมไพเลอร์ที่เหมาะสมที่จะใช้สำหรับแพลตฟอร์มที่กำหนดและใช้แฟล็กที่เหมาะสมเมื่อรวบรวมแอปพลิเคชัน บนแพลตฟอร์ม Linux หรือโอเพ่นซอร์สนี่ไม่ใช่ปัญหาเนื่องจากคุณสามารถแจกจ่ายซอร์สของคุณและสร้างสคริปต์การติดตั้งที่คอมไพล์โค้ดโดยใช้การเพิ่มประสิทธิภาพที่เหมาะสม บน windows หรือแพลตฟอร์มซอร์สแบบปิดคุณจะต้องแจกจ่ายไฟล์ปฏิบัติการหลาย ๆ ไฟล์โดยแต่ละไฟล์มีการปรับให้เหมาะสม ไบนารีของ windows ที่จะปรับใช้จะขึ้นอยู่กับ CPU ที่ตรวจพบโดยโปรแกรมติดตั้ง msi (โดยใช้การดำเนินการแบบกำหนดเอง)

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

แก้ไข: ด่าเอาชนะ 9 วิ!

หากต้องการดูว่าลูปกำลังเพิ่มประสิทธิภาพอยู่หรือไม่ให้ลองเปลี่ยนรหัสของคุณเป็น

root += Math.Sqrt(i);

ans ในทำนองเดียวกันในรหัส C จากนั้นพิมพ์ค่าของรูทนอกลูป

บางทีคอมไพเลอร์ c # สังเกตว่าคุณไม่ได้ใช้รูทที่ใดก็ได้ดังนั้นมันจึงข้ามทั้งหมดสำหรับลูป :)

นั่นอาจไม่เป็นเช่นนั้น แต่ฉันสงสัยว่าสาเหตุคืออะไรมันขึ้นอยู่กับการใช้งานคอมไพเลอร์ ลองคอมไพล์โปรแกรม C ของคุณด้วยคอมไพเลอร์ Microsoft (cl.exe ซึ่งมีให้เป็นส่วนหนึ่งของ win32 sdk) ด้วยการเพิ่มประสิทธิภาพและโหมดรีลีส ฉันพนันได้เลยว่าคุณจะเห็นการปรับปรุงที่สมบูรณ์แบบกว่าคอมไพเลอร์อื่น ๆ

แก้ไข: ฉันไม่คิดว่าคอมไพเลอร์สามารถเพิ่มประสิทธิภาพสำหรับลูปได้เพราะมันจะต้องรู้ว่า Math.Sqrt () ไม่มีผลข้างเคียงใด ๆ

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

บางทีคุณควรพยายามชนะ เทียบเท่ากับ $ / usr / bin / time my_cprog; / usr / bin / time my_csprog

ฉันรวบรวม (ตามรหัสของคุณ) การทดสอบเปรียบเทียบอีกสองรายการใน C และ C # ทั้งสองเขียนอาร์เรย์ขนาดเล็กโดยใช้ตัวดำเนินการโมดูลัสสำหรับการจัดทำดัชนี (มันเพิ่มค่าใช้จ่ายเล็กน้อย แต่เดี๋ยวก่อนเรากำลังพยายามเปรียบเทียบประสิทธิภาพ [ในระดับหยาบ])

รหัส C:

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

void main()
{
    int count = (int)1e8;
    int subcount = 1000;
    double* roots = (double*)malloc(sizeof(double) * subcount);
    clock_t start = clock();
    for (int i = 0 ; i < count; i++)
    {
        roots[i % subcount] = sqrt((double)i);
    }
    clock_t end = clock();
    double length = ((double)end - start) / CLOCKS_PER_SEC;
    printf("Time elapsed: %f\n", length);
}

ใน C #:

using System;

namespace CsPerfTest
{
    class Program
    {
        static void Main(string[] args)
        {
            int count = (int)1e8;
            int subcount = 1000;
            double[] roots = new double[subcount];
            DateTime startTime = DateTime.Now;
            for (int i = 0; i < count; i++)
            {
                roots[i % subcount] = Math.Sqrt(i);
            }
            TimeSpan runTime = DateTime.Now - startTime;
            Console.WriteLine("Time elapsed: " + Convert.ToString(runTime.TotalMilliseconds / 1000));
        }
    }
}

การทดสอบเหล่านี้เขียนข้อมูลไปยังอาร์เรย์ (ดังนั้นรันไทม์. NET จึงไม่ควรได้รับอนุญาตให้คัดแยก sqrt op) แม้ว่าอาร์เรย์จะมีขนาดเล็กลงมาก (ไม่ต้องการใช้หน่วยความจำมากเกินไป) ฉันรวบรวมสิ่งเหล่านี้ในการกำหนดค่ารุ่นและเรียกใช้จากภายในหน้าต่างคอนโซล (แทนที่จะเริ่มต้นผ่าน VS)

ในคอมพิวเตอร์ของฉันโปรแกรม C # จะแตกต่างกันไประหว่าง 6.2 ถึง 6.9 วินาทีในขณะที่เวอร์ชัน C จะแตกต่างกันไประหว่าง 6.9 ถึง 7.1

หากคุณทำโค้ดเพียงขั้นตอนเดียวในระดับแอสเซมบลีรวมถึงการก้าวผ่านรูทีนรูทที่สองคุณอาจจะได้รับคำตอบสำหรับคำถามของคุณ

ไม่จำเป็นต้องมีการคาดเดาการศึกษา

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

สำหรับฉันแล้วดูเหมือนว่านี่ไม่ได้เกี่ยวข้องกับภาษา แต่จะเกี่ยวข้องกับการใช้ฟังก์ชันรากที่สองที่แตกต่างกัน

จริงๆแล้วลูปไม่ได้รับการปรับให้เหมาะสม ฉันรวบรวมรหัสของ John และตรวจสอบ. exe ที่เป็นผลลัพธ์ ความกล้าของลูปมีดังนี้:

 IL_0005:  stloc.0
 IL_0006:  ldc.i4.0
 IL_0007:  stloc.1
 IL_0008:  br.s       IL_0016
 IL_000a:  ldloc.1
 IL_000b:  conv.r8
 IL_000c:  call       float64 [mscorlib]System.Math::Sqrt(float64)
 IL_0011:  pop
 IL_0012:  ldloc.1
 IL_0013:  ldc.i4.1
 IL_0014:  add
 IL_0015:  stloc.1
 IL_0016:  ldloc.1
 IL_0017:  ldc.i4     0x5f5e100
 IL_001c:  ble.s      IL_000a

เว้นแต่รันไทม์จะฉลาดพอที่จะรู้ว่าลูปไม่ทำอะไรเลยและข้ามไป?

แก้ไข: การเปลี่ยน C # เป็น:

 static void Main(string[] args)
 {
      DateTime startTime = DateTime.Now;
      double root = 0.0;
      for (int i = 0; i <= 100000000; i++)
      {
           root += Math.Sqrt(i);
      }
      System.Console.WriteLine(root);
      TimeSpan runTime = DateTime.Now - startTime;
      Console.WriteLine("Time elapsed: " +
          Convert.ToString(runTime.TotalMilliseconds / 1000));
 }

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