कैश लाइन आकार मापने के लिए सरल परीक्षण

Question

इस आलेख से शुरू - Gallery of Processor Cache Effects इगोर ओस्ट्रोवस्की द्वारा - मैं अपनी मशीनों पर अपने उदाहरणों के साथ खेलना चाहता था। यह पहला उदाहरण के लिए मेरी कोड, कि कैसे छू अलग कैश लाइनों पर लग रहा है चलने पर प्रभाव समय आ गया है:

:

#include <iostream> 
#include <time.h> 

using namespace std; 

int main(int argc, char* argv[]) 
{ 
    int step = 1; 

    const int length = 64 * 1024 * 1024; 
    int* arr = new int[length]; 

    timespec t0, t1; 
    clock_gettime(CLOCK_REALTIME, &t0); 
    for (int i = 0; i < length; i += step) 
     arr[i] *= 3; 
    clock_gettime(CLOCK_REALTIME, &t1); 

    long int duration = (t1.tv_nsec - t0.tv_nsec); 
    if (duration < 0) 
     duration = 1000000000 + duration; 

    cout<< step << ", " << duration/1000 << endl; 

    return 0; 
} 

कदम के लिए विभिन्न मूल्यों का उपयोग करना, मैं चल रहा समय में कूद नहीं दिख रहा है

step, microseconds 
1, 451725 
2, 334981 
3, 287679 
4, 261813 
5, 254265 
6, 246077 
16, 215035 
32, 207410 
64, 202526 
128, 197089 
256, 195154 

मैं के साथ कुछ ऐसा ही देखने की उम्मीद करेंगे:

लेकिन 16 के बाद से, चलने का समय हर बार जब हम दोगुना कदम को आधा कर दिया गया है से।

मैं इसे उबंटू 13, ज़ीऑन एक्स 5450 पर परीक्षण करता हूं और इसे संकलित करता हूं: g ++ -O0। क्या मेरे कोड के साथ कुछ गड़बड़ है, या परिणाम वास्तव में ठीक हैं? जो मुझे याद आ रही है उस पर कोई अंतर्दृष्टि अत्यधिक सराहना की जाएगी।

Answer 1

जैसा कि मैंने देखा है कि आप कैश लाइन आकारों का प्रभाव देखना चाहते हैं, मैं वाल्ग्रिंड टूल सेट का हिस्सा टूल कैशग्रींड की सलाह देता हूं। आपका दृष्टिकोण सही है लेकिन परिणामों के नजदीक नहीं है।

#include <iostream> 
#include <time.h> 
#include <stdlib.h> 

using namespace std; 

int main(int argc, char* argv[]) 
{ 
    int step = atoi(argv[1]); 

    const int length = 64 * 1024 * 1024; 
    int* arr = new int[length]; 

    for (int i = 0; i < length; i += step) 
     arr[i] *= 3; 
    return 0; 
} 

भागो उपकरण valgrind --tool = cachegrind ./a.out $ cacheline आकार और आप परिणाम दिखाई देंगे। इसे साकार करने के बाद आपको सटीकता के साथ वांछित परिणाम मिलेंगे। मुबारक प्रयोग !!

Answer 2

public class CacheLine { 

public static void main(String[] args) { 
    CacheLine cacheLine = new CacheLine(); 
    cacheLine.startTesting(); 
} 

private void startTesting() { 
    byte[] array = new byte[128 * 1024]; 
    for (int testIndex = 0; testIndex < 10; testIndex++) { 
     testMethod(array); 
     System.out.println("--------- // ---------"); 
    } 

} 

private void testMethod(byte[] array) { 
    for (int len = 8192; len <= array.length; len += 8192) { 

     long t0 = System.nanoTime(); 
     for (int i = 0; i < 10000; i++) { 
      for (int k = 0; k < len; k += 64) { 
       array[k] = 1; 
      } 
     } 

     long dT = System.nanoTime() - t0; 
     System.out.println("len: " + len/1024 + " dT: " + dT + " dT/stepCount: " + (dT)/len); 
    } 
} 
} 

यह कोड आपको एल 1 डेटा कैश आकार निर्धारित करने में मदद करता है। आप इसके बारे में अधिक विस्तार से यहां पढ़ सकते हैं। https://medium.com/@behzodbekqodirov/threading-in-java-194b7db6c1de#.kzt4w8eul