से अधिक मेरे पास एक मिलियन पूर्णांक की एक सरणी है क्योंकि मैं समांतर quicksort के साथ प्रयोग कर रहा हूं।जावा इंटीजर तुलना:
जांच करने के लिए मौसम सरणी सही ढंग से हल कर रहा था मैं छँटाई के बाद निम्नलिखित कोड में प्रवेश किया:
for(int j=0; j < array_parallel.length-1; ++j)
if(array_parallel[j] > array_parallel[j+1])
System.out.println("ERROR! NOT SORTED CORRECTLY!");
कुछ मामलों मैं त्रुटि उत्पादन कि इसे सही ढंग से हल नहीं किया गया था मिल में मैं निम्नलिखित अजीब व्यवहार कभी कभी है , और जब मैं डिबग मैं निम्नलिखित (उदाहरण के लिए, हमेशा अलग) पाते हैं:
j = 1942 array_parallel [1942] = 6000; array_parallel [1 9 43] = 6000;
(संख्या अनदेखी, इसकी न कोई विशेष मान या श्रेणी कोशिश) तो इसकी हमेशा ऐसे मामलों में जहां छोड़ दिया मूल्य सही मूल्य के बराबर में। ठीक है, अधिक की तुलना में यह झूठी में वापस आना चाहिए, लेकिन मुझे निश्चित रूप से आउटपुट मिलता है।
क्या गलत है !?
मैंने भी सरणी की जांच की है और इसे सही ढंग से क्रमबद्ध किया गया है। अगर मैं एक छोटी सी सरणी (लगभग 100) प्लॉट करता हूं तो यह भी ठीक है। क्या मुझे कुछ याद आया क्या मेरा दिमाग मुझे चाल करता है?
संपादित 21:32 (यूटीसी +1):
private static int ANZAHL = 1000000; // Größe des Arrays
public static void main(String[] args) {
// TODO Auto-generated method stub
int array_single[] = new int[ANZAHL];
int array_parallel[] = new int[ANZAHL];
Speedmeasure sp_single = new Speedmeasure();
Speedmeasure sp_parallel = new Speedmeasure();
ArrayReader ar = null;
try {
ar = new ArrayReader(array_single, array_parallel);
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (ClassNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
if(ar == null) {
System.err.println("Großes Problem. Lass es sein!");
System.exit(-1);
}
else {
for(int i=0; i < 5; ++i) {
Quicksort_Single qs = new Quicksort_Single();
sp_single.setStart(System.currentTimeMillis());
qs.quicksort_start(array_single);
sp_single.setStop(System.currentTimeMillis());
//printArray(array);
PrintSpeed(sp_single.getSpeed(), "Single");
System.out.print("\nUnd jetzt treiben wir es parallel! \n\n");
Thread t1 = new Thread(new Quicksort_Parallel(0, array_parallel.length-1, array_parallel));
sp_parallel.setStart(System.currentTimeMillis());
t1.start();
try {
t1.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
sp_parallel.setStop(System.currentTimeMillis());
//printArray(array_parallel);
PrintSpeed(sp_parallel.getSpeed(),"Parallel");
System.out.println("Speed up was: "+sp_parallel.calcSpeedup(sp_single.getSpeed(), sp_parallel.getSpeed()));
System.out.println("******************************************");
for(int j=0; j < array_single.length-1; ++j)
if(array_single[j] > array_single[j+1])
System.out.println("ERROR! NICHT SORTIERT KORREKT BEI SINGLE!");
for(int j=0; j < array_parallel.length-1; ++j)
if(array_parallel[j] > array_parallel[j+1])
System.out.println("ERROR! NICHT SORTIERT KORREKT BEI PARALLEL!");
ar.copyArray(array_single, array_parallel);
}
}
}
मैं एक धागा है कि समानांतर तरह शुरू की पर शामिल होते हैं। एक ही समय में अधिकतम 4 धागे तक स्पॉन की तुलना में पहला थ्रेड। मैं 100% निश्चित नहीं हूं कि यह कितना समेकन हो सकता है, क्योंकि मैं डीबगर में देख सकता हूं कि सरणी क्रमबद्ध है। मैं दो पूर्णांक के आउटपुट को जोड़ दूंगा और एक और नजर रखूंगा।
संपादित 23/05/12 16:46 यूटीसी +1
मैं नए के साथ काम करने से पूरी बात बदल रहा था, और वास्तव में आसान, ForkJoinPool JDK 1.7 से। 10 Mio पूर्णांकों अप करने के लिए पूर्णांक सरणियों के साथ परीक्षण किया गया और दिलचस्प परिणाम मिल गया: मैं एक Core2Duo (2010) मैकबुक प्रो और कोर-i5 (2011) विंडोज 7 पर यह परीक्षण किया है: तो
core2duo और i5 हाइपरथ्रेडिंग कर सकते हैं, मैंने अब उपलब्ध प्रोसेसर() * 2 के साथ परीक्षण किया -> कोर 2duo को 2 थ्रेड के लिए 1.8 और 1.7 तक गति के लिए थोड़ा बढ़ावा मिला; i5 वर्तमान में प्रति उपलब्ध 8 धागे के साथ 3.2 की गति के आसपास है प्रोसेसर() * 2
अभी भी मेरी मशीन से बाहर निकलने का प्रयोग कर रहा है। सभी परीक्षण एक ही सरणी के साथ किए गए थे और औसत को प्रत्येक सरणी आकार पर 1000 सॉर्टिंग पुनरावृत्तियों से गणना की गई थी।
आप चलाने के अपने एकाधिक धागे में एल्गोरिदम सॉर्टिंग? – assylias
हाँ मैं करता हूं। लेकिन जब मैं तुलना करता हूं तो वे समाप्त हो जाते हैं। – Stefan
क्या यह एक int या इंटीजर है? –