चूंकि मेरे पास एक समान प्रश्न था, इससे मुझे तेज शुरुआत मिली।
मेरा सवाल थोड़ा और अधिक विशिष्ट है, 'एक प्रतिवर्ती सरणी कार्यान्वयन के लिए सबसे तेज़ तरीका क्या है'
मार्क ग्रेवेल द्वारा किया गया परीक्षण बहुत कुछ दिखाता है, लेकिन बिल्कुल समय का उपयोग नहीं करता है। उनकी टाइमिंग में एरे के साथ-साथ लूपिंग भी शामिल है। चूँकि मैं भी एक तीसरी विधि के साथ आया था जिसे मैं परीक्षण करना चाहता था, एक 'डिक्शनरी', बस तुलना करने के लिए, मैंने हिस्ट टेस्ट कोड बढ़ाया।
फ़र्स्ट्स, मैं एक कंटीन्यूअस का उपयोग करके एक परीक्षण करता हूं, जो मुझे लूप सहित एक निश्चित समय देता है। यह वास्तविक पहुंच को छोड़कर एक 'नंगे' समय है। फिर मैं विषय संरचना तक पहुंचने के साथ एक परीक्षण करता हूं, इससे मुझे और 'ओवरहेड में शामिल' समय, लूपिंग और वास्तविक पहुंच मिलती है।
'नंगे' टाइमिंग और 'ओवरहेड इंडेडेड' टाइमिंग के बीच का अंतर मुझे 'स्ट्रक्चर एक्सेस' टाइमिंग का संकेत देता है।
लेकिन यह समय कितना सही है? परीक्षण के दौरान खिड़कियां शीर के लिए कुछ समय खिसकाएंगी। मुझे समय के बारे में कोई जानकारी नहीं है, लेकिन मुझे लगता है कि यह समान रूप से परीक्षण के दौरान और msec के दसियों के क्रम में वितरित किया गया है जिसका अर्थ है कि समय के लिए सटीकता +/- 100 मिसे या इसके क्रम में होनी चाहिए। थोड़ा मोटा अनुमान? वैसे भी एक व्यवस्थित कतरनी त्रुटि का एक स्रोत है।
इसके अलावा, परीक्षण 'डीबग' मोड में किए गए थे, जिसमें कोई इष्टतम नहीं था। अन्यथा कंपाइलर वास्तविक परीक्षण कोड को बदल सकता है।
इसलिए, मुझे दो परिणाम मिलते हैं, एक निरंतर, 'सी (') 'के लिए, और एक चिन्हित' (n) 'और' dt 'एक्सेस के लिए एक अंतर बताता है कि वास्तविक पहुँच में कितना समय लगता है।
और यह परिणाम हैं:
Dictionary(c)/for: 1205ms (600000000)
Dictionary(n)/for: 8046ms (589725196)
dt = 6841
List(c)/for: 1186ms (1189725196)
List(n)/for: 2475ms (1779450392)
dt = 1289
Array(c)/for: 1019ms (600000000)
Array(n)/for: 1266ms (589725196)
dt = 247
Dictionary[key](c)/foreach: 2738ms (600000000)
Dictionary[key](n)/foreach: 10017ms (589725196)
dt = 7279
List(c)/foreach: 2480ms (600000000)
List(n)/foreach: 2658ms (589725196)
dt = 178
Array(c)/foreach: 1300ms (600000000)
Array(n)/foreach: 1592ms (589725196)
dt = 292
dt +/-.1 sec for foreach
Dictionary 6.8 7.3
List 1.3 0.2
Array 0.2 0.3
Same test, different system:
dt +/- .1 sec for foreach
Dictionary 14.4 12.0
List 1.7 0.1
Array 0.5 0.7
समय की त्रुटियों पर बेहतर अनुमान लगाने के साथ (समय की कटौती के कारण व्यवस्थित माप त्रुटि को कैसे हटाया जाए?) परिणामों के बारे में अधिक कहा जा सकता है।
ऐसा लगता है कि लिस्ट / फ़ॉरचेज़ की सबसे तेज़ पहुंच है लेकिन ओवरहेड इसे मार रहा है।
List / for और List / foreach के बीच का अंतर स्टैंग है। शायद कुछ नकदी शामिल है?
इसके अलावा, यदि आप forलूप या लूप का उपयोग करते हैं तो यह किसी ऐरे से एक्सेस के लिए कोई मायने नहीं रखता foreach। समय के परिणाम और इसकी शुद्धता परिणाम को 'तुलनीय' बनाती है।
शब्दकोश का उपयोग करना अब तक सबसे धीमा है, मैंने केवल इस पर विचार किया क्योंकि बाईं ओर (अनुक्रमणिका) मेरे पास पूर्णांकों की एक बड़ी सूची है और इस परीक्षण में उपयोग की जाने वाली श्रेणी नहीं है।
यहाँ संशोधित परीक्षण कोड है।
Dictionary<int, int> dict = new Dictionary<int, int>(6000000);
List<int> list = new List<int>(6000000);
Random rand = new Random(12345);
for (int i = 0; i < 6000000; i++)
{
int n = rand.Next(5000);
dict.Add(i, n);
list.Add(n);
}
int[] arr = list.ToArray();
int chk = 0;
Stopwatch watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
int len = dict.Count;
for (int i = 0; i < len; i++)
{
chk += 1; // dict[i];
}
}
watch.Stop();
long c_dt = watch.ElapsedMilliseconds;
Console.WriteLine(" Dictionary(c)/for: {0}ms ({1})", c_dt, chk);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
int len = dict.Count;
for (int i = 0; i < len; i++)
{
chk += dict[i];
}
}
watch.Stop();
long n_dt = watch.ElapsedMilliseconds;
Console.WriteLine(" Dictionary(n)/for: {0}ms ({1})", n_dt, chk);
Console.WriteLine("dt = {0}", n_dt - c_dt);
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
int len = list.Count;
for (int i = 0; i < len; i++)
{
chk += 1; // list[i];
}
}
watch.Stop();
c_dt = watch.ElapsedMilliseconds;
Console.WriteLine(" List(c)/for: {0}ms ({1})", c_dt, chk);
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
int len = list.Count;
for (int i = 0; i < len; i++)
{
chk += list[i];
}
}
watch.Stop();
n_dt = watch.ElapsedMilliseconds;
Console.WriteLine(" List(n)/for: {0}ms ({1})", n_dt, chk);
Console.WriteLine("dt = {0}", n_dt - c_dt);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
for (int i = 0; i < arr.Length; i++)
{
chk += 1; // arr[i];
}
}
watch.Stop();
c_dt = watch.ElapsedMilliseconds;
Console.WriteLine(" Array(c)/for: {0}ms ({1})", c_dt, chk);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
for (int i = 0; i < arr.Length; i++)
{
chk += arr[i];
}
}
watch.Stop();
n_dt = watch.ElapsedMilliseconds;
Console.WriteLine("Array(n)/for: {0}ms ({1})", n_dt, chk);
Console.WriteLine("dt = {0}", n_dt - c_dt);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
foreach (int i in dict.Keys)
{
chk += 1; // dict[i]; ;
}
}
watch.Stop();
c_dt = watch.ElapsedMilliseconds;
Console.WriteLine("Dictionary[key](c)/foreach: {0}ms ({1})", c_dt, chk);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
foreach (int i in dict.Keys)
{
chk += dict[i]; ;
}
}
watch.Stop();
n_dt = watch.ElapsedMilliseconds;
Console.WriteLine("Dictionary[key](n)/foreach: {0}ms ({1})", n_dt, chk);
Console.WriteLine("dt = {0}", n_dt - c_dt);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
foreach (int i in list)
{
chk += 1; // i;
}
}
watch.Stop();
c_dt = watch.ElapsedMilliseconds;
Console.WriteLine(" List(c)/foreach: {0}ms ({1})", c_dt, chk);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
foreach (int i in list)
{
chk += i;
}
}
watch.Stop();
n_dt = watch.ElapsedMilliseconds;
Console.WriteLine(" List(n)/foreach: {0}ms ({1})", n_dt, chk);
Console.WriteLine("dt = {0}", n_dt - c_dt);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
foreach (int i in arr)
{
chk += 1; // i;
}
}
watch.Stop();
c_dt = watch.ElapsedMilliseconds;
Console.WriteLine(" Array(c)/foreach: {0}ms ({1})", c_dt, chk);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
foreach (int i in arr)
{
chk += i;
}
}
watch.Stop();
n_dt = watch.ElapsedMilliseconds;
Console.WriteLine("Array(n)/foreach: {0}ms ({1})", n_dt, chk);
Console.WriteLine("dt = {0}", n_dt - c_dt);
