आधुनिक DDR3 SDRAM। स्रोत: BY-SA / 4.0 Kjerish द्वारा

माउंटेन व्यू में कंप्यूटर इतिहास संग्रहालय की हालिया यात्रा पर, फेराइट मेमोरी के एक प्राचीन उदाहरण ने मेरा ध्यान आकर्षित किया।


स्रोत: BY-SA / 3.0 कोंस्टेंटिन लांज़ेट द्वारा

मैं जल्दी से इस नतीजे पर पहुंचा कि मुझे नहीं पता कि ऐसी चीजें कैसे काम करती हैं। क्या रिंग्स घूमती हैं (नहीं), और प्रत्येक रिंग में तीन तार क्यों जाते हैं (मुझे अभी भी समझ नहीं आया कि वे कैसे काम करते हैं)। इससे भी महत्वपूर्ण बात, मुझे एहसास हुआ कि मेरे पास बहुत कम विचार है कि आधुनिक गतिशील रैम कैसे काम करता है!


स्रोत: उलरिच ड्रेपर की मेमोरी साइकिल

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

इसने मुझे लंबे समय तक परेशान किया, और मैंने सोचा ... क्या कार्यक्रम स्तर पर अपडेट करने में देरी को नोटिस करना संभव है?

डायनेमिक रैम अपग्रेड ट्रेनिंग बेस

प्रत्येक DIMM में "कोशिकाएं" और "पंक्तियां", "कॉलम", "पक्ष" और / या "रैंक" होते हैं। यूटा विश्वविद्यालय की यह प्रस्तुति नामकरण की व्याख्या करती है। कंप्यूटर मेमोरी कॉन्फ़िगरेशन को decode-dimms साथ चेक किया जा सकता है। यहाँ एक उदाहरण है:

  $ डिकोड-डिम
 आकार 4096 एमबी
 बैंकों x पंक्तियाँ x कॉलम x 8 x 15 x 10 x 64 बिट्स
 रैंक 2 

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

दो स्रोतों पर विचार करें:

• यूटा विश्वविद्यालय अद्यतन ट्यूटोरियल
• और माइक्रोन की उत्कृष्ट गीगाबिट चिप प्रलेखन: "1Gb डीडीआर SDRAM के लिए TN-46-09 डिजाइनिंग"

डायनेमिक मेमोरी में प्रत्येक बिट को अपडेट किया जाना चाहिए: यह आमतौर पर हर 64 एमएस (तथाकथित स्टैटिक अपडेट) में होता है। यह एक महंगा ऑपरेशन है। प्रत्येक 64 एमएस में एक प्रमुख पड़ाव से बचने के लिए, प्रक्रिया को 8192 छोटे अपडेट ऑपरेशन में विभाजित किया गया है। उनमें से प्रत्येक में, कंप्यूटर का मेमोरी कंट्रोलर डीआरएएम चिप्स को अपडेट कमांड भेजता है। निर्देश प्राप्त करने के बाद, चिप 1/8192 कोशिकाओं को अपडेट करेगा। यदि आप गणना करते हैं, तो 64 एमएस / 8192 = 7812.5 एनएस या 7.81 μs। इसका मतलब निम्न है:

• एक अपडेट कमांड प्रत्येक 7812.5 एनएस को निष्पादित किया जाता है। इसे tREFI कहते हैं।
• अद्यतन और पुनर्प्राप्ति प्रक्रिया में कुछ समय लगता है, इसलिए चिप फिर से सामान्य पढ़ने और लिखने का संचालन कर सकती है। तथाकथित tRFC 75 ns या 120 ns (जैसा कि उल्लेखित माइक्रोन प्रलेखन में है) के बराबर है।

यदि मेमोरी गर्म है (85 डिग्री सेल्सियस से अधिक), तो मेमोरी में डेटा स्टोरेज का समय कम हो जाता है, और स्टैटिक अपडेट का समय 32 एमएस तक आधा हो जाता है। तदनुसार, tREFI 3906.25 ns पर गिर जाता है।

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

अपडेट के दौरान पूरी मेमोरी चिप ब्लॉक हो जाती है। यही है, मेमोरी में प्रत्येक बिट 75 एनएस के लिए हर 7812 एनएस पर बंद है। चलो इसे नापते हैं।

प्रयोग की तैयारी

नैनोसेकंड सटीकता के साथ संचालन को मापने के लिए, आपको बहुत तंग चक्र की आवश्यकता है, शायद सी में। यह इस तरह दिखता है:

  for (i = 0; i < ...; i++) { //   . *(volatile int *) one_global_var; //   CPU.    _mm_clflush(one_global_var); //   ,     //    (25    160). // , - . asm volatile("mfence"); //     clock_gettime(CLOCK_MONOTONIC, &ts); } 

पूरा कोड GitHub पर उपलब्ध है।

कोड बहुत सरल है। मेमोरी रीडिंग करें। हम सीपीयू कैश से डेटा डंप करते हैं। हम समय को मापते हैं।

(नोट: दूसरे प्रयोग में, मैंने डेटा लोड करने के लिए MOVNTDQA का उपयोग करने की कोशिश की, लेकिन इसके लिए एक विशेष गैर-उपलब्ध मेमोरी पेज और रूट अधिकारों की आवश्यकता है)।

मेरे कंप्यूटर पर, प्रोग्राम निम्न डेटा प्रदर्शित करता है:

  # टाइमस्टैम्प, चक्र समय
 3101895733, 134
 3101895865, 132
 3101896002, 137
 3101896134, 132
 3101896268, 134
 3101896403, 135
 3101896762, 359
 3101896901, 139
 3101897038, 137 

आमतौर पर, लगभग 140 एनएस की अवधि के साथ एक चक्र प्राप्त किया जाता है, समय-समय पर समय लगभग 360 एनएस तक बढ़ जाता है। कभी-कभी अजीब परिणाम 3200 एनएस से अधिक हो जाते हैं।

दुर्भाग्य से, डेटा बहुत शोर है। यह देखने के लिए बहुत मुश्किल है कि क्या अपडेट साइकिल के साथ ध्यान देने योग्य देरी है।

फास्ट फूरियर ट्रांसफॉर्म

कुछ बिंदु पर यह मुझ पर dawned। चूंकि हम एक निश्चित अंतराल के साथ एक घटना खोजना चाहते हैं, इसलिए हम एफएफटी एल्गोरिथ्म (तेज फूरियर ट्रांसफॉर्म) में डेटा जमा कर सकते हैं, जो मुख्य आवृत्तियों को डिक्रिप्ट करता है।

मैं इसके बारे में सोचने वाला पहला व्यक्ति नहीं हूं: मार्क सीबॉर्न ने प्रसिद्ध भेद्यता रोहमर के साथ 2015 में इस तकनीक को वापस लागू किया। मार्क के कोड को देखने के बाद भी, FFT का काम करना मेरी अपेक्षा से कठिन था। लेकिन अंत में, मैंने सभी टुकड़ों को एक साथ रखा।

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

• छोटे मान (1.8 औसत से कम) लूप पुनरावृत्तियों को काट दिया जाता है, अनदेखा किया जाता है और शून्य के साथ बदल दिया जाता है। हम वास्तव में शोर नहीं करना चाहते हैं।
• अन्य सभी रीडिंग को इकाइयों द्वारा प्रतिस्थापित किया जाता है, क्योंकि कुछ शोर के कारण देरी के आयाम वास्तव में हमारे लिए महत्वपूर्ण नहीं हैं।
• मैं 100 ns के नमूने अंतराल पर बस गया, लेकिन Nyquist फ़्रीक्वेंसी (डबल अपेक्षित फ़्रीक्वेंसी) तक कोई भी संख्या करेगा ।
• FFT में सबमिट किए जाने से पहले डेटा एक निश्चित समय पर नमूना होना चाहिए। सभी उचित नमूने के तरीके ठीक काम करते हैं, मैं बुनियादी रैखिक प्रक्षेप पर बस गया।

एल्गोरिथ्म कुछ इस तरह है:

 UNIT=100ns A = [(timestamp, loop_duration),...] p = 1 for curr_ts in frange(fist_ts, last_ts, UNIT): while not(A[p-1].timestamp <= curr_ts < A[p].timestamp): p += 1 v1 = 1 if avg*1.8 <= A[p-1].duration <= avg*4 else 0 v2 = 1 if avg*1.8 <= A[p].duration <= avg*4 else 0 v = estimate_linear(v1, v2, A[p-1].timestamp, curr_ts, A[p].timestamp) B.append( v ) 

मेरे डेटा पर इस तरह से एक उबाऊ वेक्टर का उत्पादन होता है:

  [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
  0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...] 

हालांकि, वेक्टर काफी बड़ा है, आमतौर पर लगभग 200 हजार डेटा पॉइंट। ऐसे डेटा के साथ, आप FFT का उपयोग कर सकते हैं!

 C = numpy.fft.fft(B) C = numpy.abs(C) F = numpy.fft.fftfreq(len(B)) * (1000000000/UNIT) 

बहुत आसान है, है ना? इससे दो वैक्टर बनते हैं:

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

परिणाम को एक चार्ट पर प्लॉट किया जा सकता है:



इकाइयों के बिना वाई अक्ष, जैसा कि हमने देरी समय को सामान्य किया। इसके बावजूद, कुछ निश्चित आवृत्ति श्रेणियों में फटने स्पष्ट रूप से दिखाई देते हैं। आइए उन पर विचार करें:



हम स्पष्ट रूप से पहले तीन चोटियों को देखते हैं। थोड़ा अनुभवहीन अंकगणित के बाद, औसत से कम से कम दस बार पढ़ने को छानने सहित, आप आधार आवृत्तियों को निकाल सकते हैं:

  127850.0
 127900.0
 127950.0
 255700.0
 255750.0
 255800.0
 255850.0
 255900.0
 255950.0
 383600.0
 383650.0 

हम विचार करते हैं: 1000000000 (एनएस / एस) / 127900 (हर्ट्ज) = 7818.6 एनएस

हुर्रे! आवृत्ति में पहली छलांग वास्तव में वही है जो हम खोज रहे थे, और यह वास्तव में अद्यतन समय के साथ संबंधित है।

256 kHz, 384 kHz, 512 kHz पर शेष चोटियां तथाकथित हार्मोनिक्स हैं जो 128 kHz की हमारी आधार आवृत्ति के गुणक हैं। यह एफएफटी को वर्ग तरंग की तरह कुछ करने के लिए पूरी तरह से प्रत्याशित पक्ष प्रभाव है।

प्रयोगों की सुविधा के लिए, हमने कमांड लाइन के लिए एक संस्करण बनाया। आप कोड को स्वयं चला सकते हैं। यहाँ मेरे सर्वर पर लॉन्च करने का एक उदाहरण है:

  ~ / 2018-11-मेमोरी-रिफ्रेश $ मेक
 gcc -msse4.1 -ggdb -O3 -Wall -Wextra माप-ड्रामा.c -o माप-ड्रामा
 ./measure-dram |  python3 ./analyze-dram.py
 [*] ASLR को सत्यापित करना: मुख्य = ०x५५५५५५५४ stack ९ ० स्टैक = ०x
 [] मजेदार तथ्य।  मैंने प्रति सेकंड 40663553 क्लॉक_गेटटाइम () किया
 [*] मापने MOVQ + CLFLUSH समय।  131072 पुनरावृत्तियों चल रहा है।
 [*] डेटा लिखना
 [*] इनपुट डेटा: मिन = ११ av एवीजी = १ 16६ मेड = १६ = अधिकतम = items१ =२ ​​आइटम = १३१० .२
 [*] कटऑफ रेंज २१२-inf है
 [] 127849 आइटम कटऑफ से नीचे, 0 आइटम कटऑफ से ऊपर, 3223 आइटम नॉन-जीरो
 [*] FFT रनिंग
 [*] 250kHz से नीचे 2kHz से ऊपर की आवृत्ति 7716 की परिमाण है
 [+] 2kHZ से ऊपर की आवृत्ति वाले स्पाइक्स इस प्रकार हैं:
 127906Hz 7716
 255813 हर्ट्ज 7947
 383720Hz 7460
 511626 हर्ट्ज 7141 

मुझे स्वीकार करना चाहिए, कोड पूरी तरह से स्थिर नहीं है। समस्याओं के मामले में, टर्बो बूस्ट, सीपीयू आवृत्ति स्केलिंग और प्रदर्शन के लिए अनुकूलन को अक्षम करने की सिफारिश की गई है।

निष्कर्ष

इस काम से दो मुख्य निष्कर्ष निकलते हैं।

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

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

बहुत कुछ इस लेख के दायरे से परे है। हमने मेमोरी सबसिस्टम के आंतरिक संचालन पर मुश्किल से स्पर्श किया। आगे पढ़ने के लिए, मेरा सुझाव है:

• सैंडी ब्रिज प्रोसेसर पर L3 कैश मैपिंग
• डीआरएएम में पंक्तियों और बैंकों के लिए एक भौतिक पता कैसे मैप करता है
• हन्नू हार्टिकेनन ने डीडीआर 3 एसओ-डीआईएमएम को हैक किया और इसे काम किया ... धीमा

अंत में, यहाँ पुरानी फेराइट मेमोरी का अच्छा वर्णन है:

• सिडनी विश्वविद्यालय से पीडीपी -11 फेराइट मेमोरी का स्पष्टीकरण