C निम्न स्तर की भाषा नहीं है

आपका कंप्यूटर PDP-11 का तेज़ संस्करण नहीं है

नमस्कार, हेब्र!

मेरा नाम एंटोन डोवागल है, मैं एक सी (और केवल) नहीं है।

मैं कैम्ब्रिज यूनिवर्सिटी के एक शोधकर्ता डेविड चिज़नेल के एक लेख में आया था, जिसमें वह आम तौर पर स्वीकार किए जाने वाले विचारों पर विवाद करते हैं कि सी एक निम्न-स्तरीय भाषा है, और उनके तर्क मुझे काफी दिलचस्प लगे।

हाल ही में खोजी गई कमजोरियों के प्रकाश में, मेल्टडाउन और स्पेक्टर को अपनी घटना के कारणों का पता लगाने के लिए समय निकालना चाहिए। इन दोनों कमजोरियों ने प्रोसेसर द्वारा निर्देशों के सट्टा निष्पादन का शोषण किया और एक हमलावर को तृतीय-पक्ष चैनलों के माध्यम से परिणाम प्राप्त करने की अनुमति दी। प्रोसेसर में कमजोरियां, कई अन्य लोगों के साथ, इसलिए जोड़ा गया कि सी प्रोग्रामर यह मानते रहें कि वे निम्न-स्तरीय भाषा में कार्यक्रम करते हैं, हालांकि यह दशकों से ऐसा नहीं है।

इसमें प्रोसेसर निर्माता अकेले नहीं हैं। C / C ++ कंपाइलर डेवलपर्स ने भी योगदान दिया है।

निम्न स्तर की भाषा क्या है?

अमेरिकी कंप्यूटर वैज्ञानिक और प्रथम ट्यूरिंग पुरस्कार विजेता एलन पेरलिस ने निम्नलिखित परिभाषा दी:

"एक प्रोग्रामिंग भाषा निम्न स्तर की होती है यदि उस पर लिखे गए कार्यक्रमों को गैर-आवश्यक पर ध्यान देने की आवश्यकता होती है।"

हालाँकि यह परिभाषा C को संदर्भित करती है, लेकिन यह इस बात की समझ प्रदान नहीं करती है कि लोग निम्न स्तर की भाषा में क्या देखना चाहते हैं। विभिन्न गुणों के कारण लोग भाषा को निम्न मानते हैं। एक छोर पर कोडांतरक के साथ प्रोग्रामिंग भाषाओं के पैमाने की कल्पना करें और दूसरे पर एंटरप्राइज कंप्यूटर के लिए एक इंटरफ़ेस। निम्न-स्तरीय भाषाएं लोहे के करीब हैं, जबकि उच्च-स्तरीय भाषाएं लोगों के विचार के करीब हैं।

"हार्डवेयर के करीब" होने के लिए, भाषा को उन अमूर्तताओं को प्रदान करना चाहिए जो लक्ष्य प्लेटफ़ॉर्म के सार से मेल खाते हैं। यह साबित करना आसान है कि सी पीडीपी -11 में एक निम्न-स्तरीय भाषा थी। कार्यक्रमों का क्रमिक निष्पादन, एक फ्लैट एड्रेस स्पेस, यहां तक ​​कि पूर्व और बाद के वेतन वृद्धि ऑपरेटर, पीडीपी -11 एड्रेसिंग मोड पर पूरी तरह से गिर गए।

फास्ट पीडीपी -11 एमुलेटर

स्पेक्टर और मेल्टडाउन कमजोरियों का मुख्य कारण यह है कि प्रोसेसर के निर्माता केवल तेज प्रोसेसर नहीं बनाते हैं, उन्होंने पीडीपी -11 इंटरफेस के साथ तेज प्रोसेसर बनाए। यह महत्वपूर्ण है क्योंकि यह सी प्रोग्रामर को यह विश्वास करने के लिए जारी रखने की अनुमति देता है कि उनकी भाषा हार्डवेयर के करीब है।

सी कोड एक ज्यादातर अनुक्रमिक सार ऑटोमोटन प्रदान करता है (सी 11 तक, यह पूरी तरह से अनुक्रमिक है, अगर गैर-मानक एक्सटेंशन को बाहर रखा गया है)। एक नया धागा बनाना एक लाइब्रेरी फ़ंक्शन के लिए एक कॉल है, एक ऑपरेशन जो काफी महंगा है। इसलिए, प्रोसेसर, सी कोड को निष्पादित करने के लिए जारी रखने के इच्छुक हैं, अनुदेश-स्तरीय समानता (ILP) पर भरोसा करते हैं। वे पड़ोसी संचालन का विश्लेषण करते हैं और समानांतर में स्वतंत्र संचालन करते हैं। यह प्रोसेसर को बहुत जटिल करता है और बिजली की खपत को बढ़ाता है, लेकिन प्रोग्रामर को ज्यादातर अनुक्रमिक कोड लिखने की अनुमति देता है। इसके विपरीत, ग्राफिक प्रोसेसर (जीपीयू) दूसरे तरीके से उच्च प्रदर्शन हासिल करते हैं: उन्हें समानांतर कार्यक्रम लिखने की आवश्यकता होती है।

कमांड स्तर पर उच्च समरूपता स्पेक्टर और मेल्टडाउन का प्रत्यक्ष कारण है। आधुनिक इंटेल प्रोसेसर एक साथ 180 निर्देशों तक निष्पादित होता है (अनुक्रमिक अमूर्त सी मशीन के विपरीत, जो अगले निर्देश को अगले एक शुरू होने से पहले निष्पादित करने की उम्मीद करता है)। सी कोड की एक विशिष्ट हेयुरिस्टिक से पता चलता है कि प्रत्येक सात निर्देशों के लिए औसतन एक शाखा है। यदि आप निर्देश पाइपलाइन को पूरा रखना चाहते हैं, तो आपको अगली 25 शाखाओं का अनुमान लगाने की आवश्यकता है। यह बदले में, जटिलता जोड़ता है - प्रोसेसर पहले गलत तरीके से अनुमानित शाखा की गणना करता है, और फिर गणना के परिणामों को फेंकता है, जो ऊर्जा की खपत को नकारात्मक रूप से प्रभावित करता है। इस फेंके गए डेटा में अप्रत्यक्ष परिणाम दिखाई देते हैं, जिसका उपयोग स्पेक्टर और मेल्टडाउन हमलों में किया गया था।

नाम बदलने के रजिस्टर आधुनिक प्रोसेसर में बहुत अधिक ऊर्जा और चिप क्षेत्र का उपभोग करते हैं। इसे बंद नहीं किया जा सकता है या इसकी ऊर्जा की खपत कम हो सकती है, जो कि अंधेरे सिलिकॉन युग में असुविधाजनक बनाता है, जब ट्रांजिस्टर कम होते हैं, लेकिन इसमें शामिल ट्रांजिस्टर एक मूल्यवान संसाधन होते हैं। यह उपकरण जीपीयू में अनुपस्थित है, जहां प्रारंभ में अनुक्रमिक कोड को समानांतर रूप से निष्पादित करने के बजाय थ्रेड्स का उपयोग करके संगामिति प्राप्त की जाती है। यदि निर्देशों में निर्भरताएं नहीं हैं, जिन्हें फिर से बनाने की आवश्यकता है, तो रजिस्टरों का नाम बदलने की आवश्यकता नहीं है।

सी डिजाइन के एक और मौलिक हिस्से पर विचार करें: फ्लैट मेमोरी। यह कुछ दशकों से अस्तित्व में नहीं है। एक आधुनिक प्रोसेसर में रजिस्टरों और मुख्य मेमोरी के बीच अक्सर तीन स्तर होते हैं, इस प्रकार उत्तरार्द्ध तक पहुंचने में लगने वाले समय को कम किया जाता है।

कैश प्रोग्रामर से छिपा हुआ है और इसलिए C. से दुर्गम है। कैश का प्रभावी उपयोग आधुनिक प्रोसेसर पर कोड निष्पादन को तेज करने के तरीकों में से एक है, हालांकि यह पूरी तरह से एब्सट्रैक्ट मशीन से छिपा हुआ है और प्रोग्रामर कैश कार्यान्वयन के विवरण के ज्ञान पर भरोसा करने के लिए मजबूर हैं (उदाहरण के लिए, कि दो संरेखित 64-बिट मान कुशल कोड लिखने के लिए कैश की एक पंक्ति में दिखाई दे सकते हैं)।

C अनुकूलन

निम्न-स्तरीय भाषाओं के लिए जिम्मेदार सामान्य विशेषताओं में से एक गति है। विशेष रूप से, उन्हें एक जटिल संकलक के बिना तेज कोड में अनुवाद करना आसान होना चाहिए। तर्क है कि एक स्मार्ट पर्याप्त संकलक एक भाषा को तेज बना सकता है अक्सर सी समर्थकों द्वारा अनदेखी की जाती है जब वे अन्य भाषाओं के बारे में बात करते हैं।

दुर्भाग्य से, एक सरल अनुवाद का उपयोग करके, आप सी से तेज कोड प्राप्त नहीं कर सकते।
प्रोसेसर आर्किटेक्ट चिप्स बनाने के लिए वीर प्रयास करते हैं जो सी कोड को जल्दी से निष्पादित कर सकते हैं। लेकिन प्रदर्शन के स्तर जो प्रोग्रामर देखने की अपेक्षा करते हैं वे केवल संकलक द्वारा निष्पादित अविश्वसनीय रूप से जटिल अनुकूलन की सहायता से प्राप्त किए जाते हैं।
क्लैंग कंपाइलर (एलएलवीएम के संबंधित भागों सहित) कोड की लगभग 2 मिलियन लाइनें हैं। कोड के विश्लेषण और परिवर्तन के लिए, जो कि सी को गति देने के लिए आवश्यक हैं, कोड की लगभग 200,000 पंक्तियों की आवश्यकता होती है (टिप्पणियों और रिक्त को छोड़कर)।

उदाहरण के लिए, सी में बड़ी मात्रा में डेटा को संसाधित करने के लिए, आपको एक लूप लिखना होगा जो प्रत्येक तत्व को क्रमिक रूप से संसाधित करता है। आधुनिक प्रोसेसर पर इस चक्र के इष्टतम निष्पादन के लिए, संकलक को यह निर्धारित करना होगा कि चक्र की पुनरावृत्तियां एक दूसरे से स्वतंत्र हैं। प्रतिबंधित कीवर्ड इस मामले में मदद कर सकता है - यह सुनिश्चित करता है कि एक पॉइंटर को लिखता है दूसरे पॉइंटर से पढ़ने में हस्तक्षेप नहीं करेगा। सी में यह जानकारी फोरट्रान जैसी भाषा की तुलना में बहुत अधिक सीमित है, जो मुख्य कारण है कि सी इसे उच्च-प्रदर्शन कंप्यूटिंग से बाहर करने में असमर्थ था।

संकलक निर्धारित करने के बाद कि पुनरावृत्तियां एक दूसरे से स्वतंत्र हैं, अगला चरण परिणाम को वेक्टर करने का एक प्रयास है, क्योंकि आधुनिक प्रोसेसर का प्रवाह स्केलर कोड की तुलना में वेक्टर कोड के लिए चार से आठ गुना अधिक है। ऐसे प्रोसेसर के लिए निम्न-स्तरीय भाषा की अपनी वेक्टर प्रकार की मनमानी लंबाई होगी। इस प्रकार के मध्यवर्ती एलएलवीएम प्रतिनिधित्व में मौजूद हैं, क्योंकि बड़े वेक्टर ऑपरेशन के निर्माण की तुलना में वैक्टर के साथ बड़े ऑपरेशन को कई छोटे में विभाजित करना हमेशा आसान होता है।

इस बिंदु पर, ऑप्टिमाइज़र को सी मेमोरी नियमों के साथ संघर्ष करना पड़ता है। सी यह सुनिश्चित करता है कि एक ही उपसर्ग के साथ संरचनाओं का परस्पर उपयोग किया जा सकता है, और भाषा में संरचनाओं के ऑफसेट फ़ील्ड फ़ील्ड तक पहुंच प्रदान करता है। इसका मतलब है कि संकलक संरचना में फ़ील्ड्स के क्रम को बदल नहीं सकता है या वेक्टराइजेशन को बेहतर बनाने के लिए संरेखण को जोड़ सकता है (उदाहरण के लिए, सरणियों से संरचनाओं की एक सरणी या इसके विपरीत में संरचना बदलना)। यह आमतौर पर निम्न-स्तरीय भाषाओं में एक समस्या नहीं है, जहां संरचना में खेतों के स्थान को नियंत्रित करना संभव है, लेकिन यह सी को तेज करने का कार्य करता है।

सी को संरचना के अंत में भी संरेखण की आवश्यकता होती है, क्योंकि यह सुनिश्चित करता है कि सरणियों में संरेखण नहीं है। संरेखण सी विनिर्देश का एक बल्कि जटिल हिस्सा है, जो भाषा के अन्य भागों के साथ खराब तरीके से बातचीत करता है। उदाहरण के लिए, आपको दो संरचनाओं की तुलना करने में सक्षम होना चाहिए टाइपलेस तुलना विधि (वह है, मेम्कंप () फ़ंक्शन), इसलिए संरचना की प्रतिलिपि भी गठबंधन की जानी चाहिए। कुछ मामलों में, संरेखण की प्रतिलिपि बनाने में काफी समय लगता है।

उन दो मूल अनुकूलन पर विचार करें जो सी कंपाइलर पैदा करता है: एसआरओए (एग्रीगेट्स का स्केलर रिप्लेसमेंट, एग्रीगेट्स का स्केलर रिप्लेसमेंट) और लूप ओपनिंग ।

एसआरए अलग-अलग चर के साथ निश्चित आकार की संरचनाओं और सरणियों को बदलने की कोशिश कर रहा है। यह संकलक को एक दूसरे से स्वतंत्र रूप से उन तक पहुंचने की प्रक्रिया की अनुमति देता है और ऑपरेशन को अनदेखा करता है, अगर यह स्पष्ट है कि इसका परिणाम उपयोग नहीं किया गया है। कुछ मामलों में, इस अनुकूलन का अप्रत्यक्ष प्रभाव संरेखण को हटाने के लिए है।

दूसरा अनुकूलन, लूप खोलना, लूप को दोनों शाखाओं में अलग-अलग छोरों के साथ स्थिति में परिवर्तित करता है। यह निष्पादन के क्रम में परिवर्तन का विरोध करता है क्योंकि प्रोग्रामर जानता है कि निम्न-स्तरीय भाषा में क्या निष्पादित किया जाएगा। और यह भी गंभीर समस्याएं पैदा करता है कि C अपरिभाषित चर और अपरिभाषित व्यवहार को कैसे संभालता है।

सी में, एक अनियंत्रित चर में एक अपरिभाषित मूल्य होता है, जो प्रत्येक कॉल के साथ अलग हो सकता है। यह महत्वपूर्ण है क्योंकि यह आपको स्मृति पृष्ठों के आलसी रीसाइक्लिंग को लागू करने की अनुमति देता है। उदाहरण के लिए, FreeBSD में, मॉलोक () कार्यान्वयन सिस्टम को बताता है कि पृष्ठ अब उपयोग में नहीं हैं, और सिस्टम पृष्ठ में पहली प्रविष्टि को सबूत के रूप में उपयोग करता है कि यह मामला नहीं है। नई आवंटित मेमोरी के लिए अपील करने से पुराना मूल्य मिल सकता है, फिर ऑपरेटिंग सिस्टम मेमोरी पेज का पुन: उपयोग कर सकता है, और फिर अगली बार जब आप पृष्ठ पर किसी अन्य स्थान पर लिखते हैं तो इसे शून्य-भरे पृष्ठ से बदल सकते हैं। पृष्ठ पर उसी स्थान पर दूसरी कॉल करने पर शून्य मान मिलेगा।

यदि स्थिति अपरिभाषित मान का उपयोग करती है, तो परिणाम भी परिभाषित नहीं है - कुछ भी हो सकता है। एक लूप ओपन ऑप्टिमाइज़ेशन की कल्पना करें जहां एक लूप को शून्य बार निष्पादित किया जाता है। मूल में, पूरा लूप मृत कोड है। खुले संस्करण में अब एक वैरिएबल के साथ एक शर्त है जिसे आरंभिक नहीं किया जा सकता है।
नतीजतन, मृत कोड को अपरिभाषित व्यवहार में परिवर्तित किया जा सकता है। यह सिर्फ कई अनुकूलन में से एक है, जब अधिक अच्छी तरह से सी के शब्दार्थ की खोज करते हैं, तो अविश्वसनीय हो जाते हैं।

अंत में, आप सी कोड को तेजी से चला सकते हैं, लेकिन केवल हजारों मानव-वर्ष खर्च करने के बाद एक स्मार्ट पर्याप्त संकलक बना सकते हैं। लेकिन यह तभी संभव है जब भाषा के कुछ नियमों का उल्लंघन किया जाए। कंपाइलर निर्माता सी प्रोग्रामर को कल्पना करने की अनुमति देते हैं कि वे कोड लिखते हैं जो "हार्डवेयर के करीब" है, लेकिन उन्हें मशीन कोड उत्पन्न करना होगा जो अलग तरह से व्यवहार करता है ताकि प्रोग्रामर यह विश्वास करते रहें कि वे एक तेज भाषा में लिखते हैं।

समझना C

निम्न-स्तरीय भाषा की मूल विशेषताओं में से एक यह है कि प्रोग्रामर आसानी से समझ सकते हैं कि कैसे एक अमूर्त भाषा मशीन को एक भौतिक मशीन में स्थानांतरित किया जाता है। यह निश्चित रूप से पीडीपी -11 पर मामला था, जहां सी अभिव्यक्तियों का एक या दो निर्देशों में अनुवाद किया गया था। इसी तरह, संकलक ने चर को स्टैक स्लॉट में डाल दिया और पीडीपी -11 के लिए सरल प्रकारों को समझने योग्य में बदल दिया।

तब से, सी कार्यान्वयन बहुत अधिक जटिल हो गया है - इस भ्रम को बनाए रखने के लिए कि सी आसानी से एक हार्डवेयर प्लेटफॉर्म पर पोर्ट किया गया है और तेजी से चलता है। 2015 में, सी प्रोग्रामर, संकलक लेखकों और मानकीकरण समिति के सदस्यों के बीच एक सर्वेक्षण से पता चला कि सी को समझने में समस्याएं थीं । उदाहरण के लिए, यह भाषा कार्यान्वयन को संरचनाओं के लिए संरेखण को जोड़ने की अनुमति देती है (लेकिन सरणियों के लिए नहीं) यह सुनिश्चित करने के लिए कि सभी फ़ील्ड लक्ष्य प्लेटफ़ॉर्म के लिए सही ढंग से संरेखित हैं। यदि आप इस संरचना को शून्य से भरते हैं और फिर कुछ क्षेत्रों के लिए एक मान निर्दिष्ट करते हैं, तो क्या संरेखण बिट्स में शून्य होगा? सर्वेक्षण के अनुसार, 36% वे सुनिश्चित थे, और 29% को उत्तर नहीं पता था। संकलक और अनुकूलन के स्तर के आधार पर, यह सच हो सकता है (या नहीं)।

यह एक बहुत ही मामूली उदाहरण है, लेकिन कई प्रोग्रामर या तो गलत जवाब देते हैं या बिल्कुल भी जवाब नहीं दे सकते हैं।

यदि आप पॉइंटर्स जोड़ते हैं, तो C का शब्दार्थ और भी भ्रामक हो जाता है। BCPL मॉडल बहुत सरल था: सभी अर्थ शब्द हैं। प्रत्येक शब्द या तो डेटा या मेमोरी में एक पता है। मेमोरी एड्रेस द्वारा अनुक्रमित कोशिकाओं का एक फ्लैट सरणी है।

मॉडल सी अलग-अलग प्लेटफार्मों के लिए कार्यान्वयन की अनुमति देता है, जिसमें खंडित आर्किटेक्चर शामिल हैं, जहां पॉइंटर सेगमेंट आईडी और ऑफसेट के साथ-साथ एक कचरा कलेक्टर के साथ वर्चुअल मशीन भी शामिल हो सकता है। C विनिर्देशन ऐसे सिस्टम के साथ समस्याओं से बचने के लिए पॉइंटर संचालन की अनुमति देता है। दोष रिपोर्ट 260 की प्रतिक्रिया सूचक की उत्पत्ति का उल्लेख करती है:

“कार्यान्वयन बिट्स के एक सेट की उत्पत्ति का पालन कर सकते हैं और उन लोगों को अलग से एक अपरिभाषित मूल्य वाले हैंडल कर सकते हैं जो एक विशिष्ट होते हैं। "वे अपने मूल के आधार पर अलग-अलग बिंदुओं को संभाल सकते हैं, भले ही वे अपने बिट मूल्य के संदर्भ में समान हों।"

दुर्भाग्य से, शब्द "उत्पत्ति" C11 विनिर्देशन से गायब है, इसलिए संकलक खुद तय करते हैं कि इसका क्या मतलब है। उदाहरण के लिए, जीसीसी और क्लैंग, इस बात में भिन्न हैं कि क्या सूचक जो पूर्णांक और पीठ में परिवर्तित किया गया था, अपनी उत्पत्ति को बरकरार रखता है। कंपाइलर यह तय कर सकते हैं कि दो अंकक माॅलोक () की तुलना में हमेशा एक नकारात्मक परिणाम देते हैं, भले ही वे एक ही पते पर हों।

ये गलतफहमी विशुद्ध रूप से अकादमिक नहीं हैं। उदाहरण के लिए, कमजोरियां पहले ही देखी जा चुकी हैं, जो NULL के लिए जाँच करने से पहले एक हस्ताक्षरित पूर्णांक (C में अपरिभाषित व्यवहार) या किसी सूचक को निष्क्रिय करने का परिणाम थे, इस तथ्य के बावजूद कि संकलक को बताया गया था कि सूचक NULL नहीं हो सकता है।

यदि ऐसी समस्याएं हैं, तो एक प्रोग्रामर से पूरी तरह से यह समझना मुश्किल है कि सी प्रोग्राम उपयुक्त आर्किटेक्चर में कैसे अनुवाद करता है।

पेश है सी के लिए प्रोसेसर नहीं

स्पेक्टर और मेल्टडाउन के खिलाफ की रक्षा के लिए प्रस्तावित पैच पिछले एक दशक में सभी माइक्रोआर्किटेक्चर उपलब्धियों को कम करते हुए, गंभीर प्रदर्शन में गिरावट का कारण बनते हैं। शायद यह सोचने का समय है कि सी कोड को कैसे तेज किया जाए, और इसके बजाय प्रोसेसर पर नए प्रोग्रामिंग मॉडल के बारे में सोचें जो गति के लिए डिज़ाइन किए गए हैं।

आर्किटेक्चर के कई उदाहरण हैं जिन्होंने पारंपरिक सी कोड पर ध्यान केंद्रित नहीं किया है और जिनसे प्रेरणा मिलती है। उदाहरण के लिए, मल्टीथ्रेडिंग-ओरिएंटेड प्रोसेसर जैसे कि सन / ओरेकल अल्ट्रास्पार्क टीएक्स को अपने एक्ट्यूएटर्स को व्यस्त रखने के लिए अधिक कैश की आवश्यकता नहीं होती है। अनुसंधान प्रोसेसर ने इस अवधारणा को बहुत बड़ी संख्या में हार्डवेयर-नियोजित थ्रेड्स में विस्तारित किया है। मुख्य विचार यह है कि, पर्याप्त थ्रेड्स के साथ, प्रोसेसर उन थ्रेड्स को रोक सकता है जो डेटा की प्रतीक्षा कर रहे हैं और अन्य थ्रेड्स के निर्देशों के साथ एक्चुएटर्स को पॉप्युलेट करते हैं। समस्या यह है कि सी कार्यक्रमों में आमतौर पर बहुत कम धागे होते हैं।

एआरएम का एसवीई (स्केलर वेक्टर एक्सटेंशन, स्केलर वेक्टर एक्सटेंशन) बर्कले का एक और समान काम है, जो कार्यक्रम और हार्डवेयर के बीच बेहतर इंटरफ़ेस पर एक नज़र डालता है। नियमित वेक्टरकरण ब्लॉक एक निश्चित आकार के वैक्टर के साथ संचालन को लागू करते हैं और उम्मीद करते हैं कि कंपाइलर निर्धारित आकार में एल्गोरिदम को अनुकूलित करेगा। इसके विपरीत, एसवीई इंटरफ़ेस प्रोग्रामर को स्वतंत्र रूप से समानता के स्तर का वर्णन करने के लिए प्रेरित करता है और हार्डवेयर को उपलब्ध एक्ट्यूएटर्स के अनुकूल होने की उम्मीद करता है। सी में इसका उपयोग करना मुश्किल है क्योंकि ऑटो-वेक्टर को कोड में छोरों के आधार पर समानता की गणना करने की आवश्यकता है।

कैश बड़े हैं, लेकिन यह उनकी जटिलता का एकमात्र कारण नहीं है। कैश जुटना समर्थन प्रोटोकॉल एक आधुनिक प्रोसेसर के सबसे जटिल घटकों में से एक है। अधिकांश कठिनाई एक भाषा को बनाए रखने से होती है जिसमें डेटा साझा और परिवर्तनशील दोनों हो सकता है। एक विपरीत उदाहरण के रूप में, हम एक अमरल एर्लांग शैली की मशीन का उपयोग कर सकते हैं, जहां प्रत्येक वस्तु या तो स्थानीय या अपरिवर्तनीय होती है। ऐसी प्रणाली के लिए कैश सुसंगतता प्रोटोकॉल में केवल दो मामले होंगे: परस्पर डेटा और साझा डेटा। प्रोग्राम स्ट्रीम का कैश जिसे किसी अन्य प्रोसेसर में स्थानांतरित किया गया था, उसे स्पष्ट रूप से अक्षम किया जाना चाहिए, लेकिन यह अपेक्षाकृत दुर्लभ ऑपरेशन है।

अपरिवर्तनीय वस्तुएं कैश को और भी सरल बना सकती हैं, और कुछ ऑपरेशनों को सस्ता भी कर सकती हैं। सन लैब्स की एक मैक्सवेल परियोजना में, यह नोट किया गया था कि कैश और हाल ही में बनाई गई वस्तुएं लगभग हमेशा समान होती हैं। यदि ऑब्जेक्ट कैश से बाहर रखे जाने से पहले मर जाते हैं, तो आप उन्हें मुख्य मेमोरी में नहीं लिख सकते हैं और इस तरह ऊर्जा की खपत को बचा सकते हैं। मैक्सवेल परियोजना ने एक कचरा कलेक्टर का प्रस्ताव रखा जो कैश में काम करता था और आपको मेमोरी को जल्दी से रीसायकल करने की अनुमति देता था। ढेर और उत्परिवर्तनीय स्टैक पर अपरिवर्तनीय वस्तुओं के साथ, कचरा कलेक्टर एक बहुत ही सरल राज्य मशीन बन जाता है, जो आसानी से हार्डवेयर में लागू होता है और आपको अपेक्षाकृत छोटे कैश का कुशलतापूर्वक उपयोग करने की अनुमति देता है।

एक प्रोसेसर जो केवल गति के लिए डिज़ाइन किया गया है, और गति और सी समर्थन के बीच व्यापार-बंद के लिए नहीं, संभवतः बड़ी संख्या में थ्रेड्स का समर्थन करना चाहिए, बड़े वेक्टरकरण ब्लॉक और एक सरल मेमोरी मॉडल है। ऐसे प्रोसेसर पर सी कोड को निष्पादित करना मुश्किल होगा, इसलिए, दुनिया में पुराने सी कोड की मात्रा को देखते हुए, इसे व्यावसायिक सफलता की संभावना नहीं है।

सॉफ्टवेयर विकास के क्षेत्र में, एक मिथक है कि समानांतर प्रोग्रामिंग मुश्किल है। यह सुनकर एलन के को बहुत हैरानी होगी: उन्होंने बच्चों को अभिनेता मॉडल का उपयोग करना सिखाया, जिसके साथ उन्होंने 200 से अधिक विधाओं पर कार्यक्रम लिखे। यह एरलांग प्रोग्रामर्स के लिए भी अज्ञात है, जो अक्सर हजारों समानांतर घटकों के साथ कार्यक्रम लिखते हैं। यह कहना अधिक सही है कि सी। जैसी अमूर्त मशीन वाली भाषा में समानांतर प्रोग्रामिंग मुश्किल है और यदि आप समानांतर हार्डवेयर (मल्टी-कोर प्रोसेसर से मल्टी-कोर जीपीयू) की प्रबलता पर ध्यान देते हैं, तो यह कहने का एक और तरीका है - सी आधुनिक हार्डवेयर के लिए उपयुक्त नहीं है सॉफ्टवेयर।