सीरियल कोड सी में केवल एक धागे का उपयोग करने से बहुत धीमी है?

Question

तो, मैं थ्रेड के साथ कुछ बेंचमार्क परीक्षण कर रहा था, और मैंने कोड के इन टुकड़े लिखे थे:

resp_threadless [] और resp_threaded [] वैश्विक int arrays हैं और उनका आकार n है;

function(); 

और दूसरा एक इस तरह::

HANDLE hThreadArray[1]; 
DWORD dwThreads[1]; 
hThreadArray[0] = CreateThread(NULL, 0, function_th, NULL , 0, &(dwThreads[0])); 
WaitForMultipleObjects(1, hThreadArray, TRUE, INFINITE); 
CloseHandle(hThreadArray[0]); 

ध्यान रखें मुझे पता है कि कि function_th का उपयोग कर एक से अधिक थ्रेड बुला

int n = 100000; 

void function() { 
    for (long j = 0; j < n; ++j) { 
    int count = 0; 
    double x = vetor[j]; 
     while (x > 1.0) { 
     x = sqrt(x); 
     ++count; 
    } 
    resp_threadless[j] = count; 
    } 
} 

DWORD WINAPI function_th(LPVOID lpParam) { 
for (long j = 0; j < n; ++j) { 
    int count = 0; 
    double x = vetor[j]; 
     while (x > 1.0) { 
     x = sqrt(x); 
     ++count; 
    } 
    resp_threadless[j] = count; 
    } 
} 

मैं सिर्फ उसे फोन करके पहले समारोह बेंचमार्क() इसे समानांतर नहीं करेगा, यह सिर्फ एक परीक्षण है क्योंकि मुझे वास्तव में अजीब परिणाम मिल रहे थे, इसलिए मैंने यह देखने का फैसला किया कि एक थ्रेड के साथ क्या होगा और एक ही कोड का उपयोग करके एक फ़ंक्शन होगा। का उपयोग करते हुए इसी तरह के परिणाम 425 एमएस

मैं लिया है: सीरियल कोड: 1485 एमएस एक धागा NUMPROC = 1.

परिणाम के साथ

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

क्या किसी को भी पता चल सकता है कि क्या हो सकता है?

संपादित

, आदेश Inverting कई बार हर एक, आदि चल रहा है ... -> कोई परिवर्तन नहीं

उच्चतर एन -> थ्रेड एक आनुपातिक भी तेजी से

QueryPerformanceCounter (का उपयोग करना है) -> कोई परिवर्तन नहीं

धागा निर्माण ओवरहेड -> पिरोया एक भी धीमी, नहीं तेजी से करना चाहिए

01,235,

मूल कोड: http://pastebin.com/tgmp5p1G

Answer 1

यह cache hit मामला है। मुझे संदेह है कि आपने अपने प्रश्न में वर्णित क्रम में बेंचमार्क किया था। समारोह को पहले कहा जाता था और थ्रेड को बाद में बुलाया गया था। जब आप इसे अधिक विस्तार से बेंचमार्क करते हैं, तो आप कारण देखेंगे: डेटा (वर्ग) कैश में availabel है, इस प्रकार कोड बहुत तेज निष्पादित करेगा। टेस्ट proove करने:

1. धागा कॉल करने से पहले दो बार या यहाँ तक कि function() भागो अधिक बार। फ़ंक्शन करने वाला दूसरा कॉल पहले से ही त्वरित परिणाम देगा।
2. फ़ंक्शन से पहले थ्रेड को कॉल करें और आपका परिणाम विपरीत दिखाएगा। फ़ंक्शन बेहतर परिणाम दिखाएगा।

कारण: सभी वर्ग गणना (या कम से कम उनमें से बहुत सारे) कैश में उपलब्ध हैं और फिर से गणना नहीं की जानी चाहिए। यह बहुत तेज़ है।