सी #

Question

में एमडीहल का कानून उदाहरण मैं कुछ पक्षाघात के साथ काम कर रहा था और इससे मुझे अमाहल के कानून में शामिल किया गया। मैंने विषय पर कई पोस्ट पढ़ी हैं;

Calculate performance gains using Amdahl's Law

How to calculate Amadahl's Law for threading effectiveness

http://en.wikipedia.org/wiki/Amdahl%27s_law

... लेकिन एक सी # व्यवहार में यह दिखा उदाहरण खोजने के लिए उम्मीद कर रहा था। खोज ने कोई परिणाम साबित नहीं किया है। सिद्धांत रूप में एक सीरियल एप्लिकेशन बनाना, समानांतर भागों को समय बनाना, एक समानांतर संस्करण चलाएं, समानांतर भागों को लेते हुए लंबाई को रिकॉर्ड करना और अंतर की तुलना करना (जानना कि कितने प्रोसेसर का उपयोग किया जा रहा है) Amdahl के फ़ंक्शन के परिणामस्वरूप। क्या यह सही है और क्या कोई इस तरह के एक उदाहरण के बारे में पता है?

Answer 1

नोट: कार्यक्रम की एक पूरी काम कर डाउनलोड करने योग्य संस्करण My Github Page

तो Amdahl की विधि के साथ पर पाया जा सकता है, हम करने के लिए काम करते हैं और "काम" काम है कि सीरियल में चलाना चाहिए "कि जा parallelized कर सकते हैं विभाजित ", तो चलो List<Action> के रूप में उन दो वर्कलोड का प्रतिनिधित्व करते हैं:

var serialWorkLoad = new List<Action> { DoHeavyWork, DoHeavyWork }; 
var parallelizableWorkLoad = new List<Action> { DoHeavyWork, DoHeavyWork, DoHeavyWork, DoHeavyWork, DoHeavyWork, DoHeavyWork, DoHeavyWork, DoHeavyWork }; 

कहाँ DoHeavyWork प्रतिनिधि के रूप में शानदार ढंग से निकाला गया है:

static void DoHeavyWork() 
{ 
    Thread.Sleep(500); 
} 

जैसा कि आप देख सकते हैं कि मैंने समानांतर वर्कलोड को मज़ेदार के लिए थोड़ा भारी बना दिया है और इसका एक अच्छा उदाहरण बना दिया है।

अगला हम अपने आधारभूत पाने के लिए सीरियल में दोनों वर्कलोड चलाने के लिए है:

var stopwatch = new Stopwatch(); 
stopwatch.Start(); 
// Run Serial-only batch of work 
foreach (var serialWork in serialWorkLoad) 
{ 
    serialWork(); 
} 

var s1 = stopwatch.ElapsedMilliseconds; 

// Run parallelizable batch of work in serial to get our baseline 
foreach (var notParallelWork in parallelizableWorkLoad) 
{ 
    notParallelWork(); 
} 

stopwatch.Stop(); 
var s2 = stopwatch.ElapsedMilliseconds - s1; 

इस बिंदु पर हम कब तक यह धारावाहिक में चलाने के लिए प्रत्येक काम का बोझ ले लिया है। अब, समानांतर भाग समानांतर के साथ, इसे फिर से चलाएं।

stopwatch.Reset(); 
stopwatch.Start(); 
// Run Serial-only batch of work 
foreach (var serialWork in serialWorkLoad) 
{ 
    serialWork(); 
} 

var p1 = stopwatch.ElapsedMilliseconds; 

// Run parallelizable batch of work in with as many degrees of parallelism as we can 
Parallel.ForEach(parallelizableWorkLoad, (workToDo) => workToDo()); // In Java this is Magic Unicorns 

stopwatch.Stop(); 
var p2 = stopwatch.ElapsedMilliseconds - p1; 

अब जब हम आधारभूत और parallelized संस्करण है, हम speedup की गणना करने और हमारे निष्कर्ष रिपोर्ट कर सकते हैं:

var speedup = (double)(s1 + s2)/(p1 + p2); 

Console.WriteLine("Serial took : {2}ms, {0}ms for serial work and {1}ms for parallelizable work", s1, s2, s1 + s2); 
Console.WriteLine("Parallel took: {2}ms, {0}ms for serial work and {1}ms for parallelizable work", p1, p2, p1 + p2); 
Console.WriteLine("Speedup was {0:F}x", speedup); 

और जैसा कि Amdahl की विधि आपको बताता है, इसके साथ किसी पैमाने पर कठिन है सीरियल-केवल काम के कारण आपके पास कोर का # है।