C++ बनाम असेंबली: क्यों कंपाइलर मैन्युअल कोड से आगे निकल जाता है

परिचय: कंप्यूटर प्रोग्रामर से तेज़ क्यों "सोचता" है?

कल्पना करें: आपने एक शाम बिताई, कागज पर संख्या 27 के लिए कोलाट्ज़ अनुक्रम लिखते हुए। और फिर आपके सहकर्मी ने C++ में एक लूप लिखा, जिसने एक सेकंड में एक अरब संख्याओं को संसाधित कर दिया। आप गुस्से में हैं? रुकिए, यह तो केवल शुरुआत है।

2025 में, Stack Overflow पर एक पुराना लेकिन बहुत ही महत्वपूर्ण प्रश्न फिर से उभरा: "Why does C++ code for testing the Collatz conjecture run faster than hand-written assembly?". ऐसा लगता है, असेंबली प्रोसेसर के साथ एक शुद्ध संवाद है, बिना किसी मध्यस्थ के। ऐसा कैसे होता है कि उच्च-स्तरीय C++ मानव द्वारा लिखी गई असेंबली से आगे निकल जाता है?

आइए इस विरोधाभास को कोलाट्ज़ परिकल्पना (जिसे 3n+1 समस्या भी कहा जाता है) के उदाहरण से समझते हैं। आप जानेंगे कि आधुनिक C++ कंपाइलर वास्तविक टाइम मशीन क्यों हैं, और 2025 में ऐसा कोड कैसे लिखें जो रजिस्टरों के "मैन्युअल" प्रबंधन से भी तेज़ होगा।

कोलाट्ज़ परिकल्पना क्या है और इसमें C++ का क्या संबंध है?

सार याद करें: कोई भी प्राकृतिक संख्या n लें। यदि वह सम है - 2 से भाग दें। यदि विषम है - 3 से गुणा करें और 1 जोड़ें। परिकल्पना कहती है कि कोई भी संख्या देर-सबेर एक पर पहुँचेगी। प्रोग्रामर का काम जितनी संभव हो सके उतनी बड़ी संख्याओं की श्रेणी के लिए इसकी जाँच करना है।

C++ में क्लासिक कार्यान्वयन इस प्रकार दिखता है:

#include <iostream>\n\nint collatz_steps(long long n) {\n    int steps = 0;\n    while (n != 1) {\n        if (n % 2 == 0) {\n            n /= 2;\n        } else {\n            n = 3 * n + 1;\n        }\n        ++steps;\n    }\n    return steps;\n}\n\nint main() {\n    long long max_steps = 0;\n    long long best_num = 0;\n    for (long long i = 1; i <= 1000000; ++i) {\n        int s = collatz_steps(i);\n        if (s > max_steps) {\n            max_steps = s;\n            best_num = i;\n        }\n    }\n    std::cout << "संख्या: " << best_num << " चरण: " << max_steps;\n}\n

यह कुछ जटिल नहीं लगता। लेकिन इस सरल कोड ने ही असेंबली के साथ एक पौराणिक बहस को जन्म दिया।

असेंबली क्यों हारती है? 2025 की मुख्य गलतियाँ

जब कोई डेवलपर असेंबली में लिखता है, तो वह अक्सर सोचता है: "मैं जानता हूँ कि प्रोसेसर कैसे काम करता है, मैं पूरी तरह से लिखूंगा"। लेकिन आधुनिक प्रोसेसर केवल निर्देशों को निष्पादित करने वाले नहीं हैं। वे शाखा पूर्वानुमान, सट्टा निष्पादन और कैश मेमोरी के साथ जटिल सुपरस्केलर पाइपलाइन हैं। C++ कंपाइलर (GCC, Clang, MSVC) अपने लक्ष्य आर्किटेक्चर के बारे में सब कुछ जानता है।

गलती #1: शाखा ऑप्टिमाइज़ेशन की अनदेखी

मैन्युअल असेंबली में, प्रोग्रामर अक्सर शाखाओं को सीधे लिखता है:

; छद्म-असेंबली\ncheck_even:\n    test rax, 1\n    jnz is_odd\n    shr rax, 1\n    jmp next\nis_odd:\n    mov rbx, rax\n    shl rax, 1\n    add rax, rbx\n    inc rax\nnext:\n    ...

C++ कंपाइलर -O3 फ्लैग के साथ अधिक चालाकी से काम करता है। वह CMOV (conditional move) और बिट मैजिक का उपयोग करता है। शाखा के बजाय - अंकगणित:

; GCC 14 कुछ इस तरह उत्पन्न करेगा:\n    mov     rcx, rax\n    shr     rcx, 1          ; 2 से भाग (यदि सम)\n    and     eax, 1          ; न्यूनतम बिट की जाँच\n    lea     rdx, [rax + rcx*2 + 1] ; विषम के लिए चालाक गणना\n    test    eax, eax\n    cmove   rax, rcx        ; यदि सम - भाग लें\n    cmovne  rax, rdx        ; यदि विषम - 3n+1 लें\n

परिणाम: गलत अनुमानित संक्रमणों के कारण कोई पाइपलाइन स्टॉल नहीं। 2025 में यह महत्वपूर्ण है, क्योंकि CPU में शाखा पूर्वानुमानकर्ता अधिक स्मार्ट हो गया है, लेकिन फिर भी यादृच्छिक संख्याओं के लिए आदर्श नहीं है।

गलती #2: वेक्टराइज़ेशन (AVX-512) को भूलना

आधुनिक C++ कंपाइलर (विशेष रूप से Clang 18+ और GCC 14+) स्वचालित रूप से लूप को वेक्टराइज़ करते हैं। यदि आप जाँच का एक सरल लूप लिखते हैं, तो कंपाइलर एक क्लॉक साइकल में एक साथ 8 संख्याओं को संसाधित कर सकता है।