टीपीएल

Question

का उपयोग कर सहकारी मल्टीटास्किंग हम मॉडलिंग अनुप्रयोग को पोर्ट कर रहे हैं, जो मॉडलिंग प्रक्रिया में कस्टम क्रियाओं के लिए आयरनपीथन स्क्रिप्ट का उपयोग करता है। मौजूदा एप्लिकेशन प्रत्येक पायथन स्क्रिप्ट को अलग थ्रेड में निष्पादित करता है और इसके लिए सहकारी मॉडल का उपयोग करता है। अब हम इसे टीपीएल को बंद करना चाहते हैं, लेकिन पहले हम संदर्भ स्विचिंग को मापना चाहते हैं। असल में, क्या हम अभी:

1. Task रों कतार
2. प्रत्येक Task इस पंक्ति से कार्यान्वित एक IronPython स्क्रिप्ट
3. IronPython स्क्रिप्ट के अंदर हम सी # वर्ग विधि है, जो तुल्यकालन बिंदु है और स्थानांतरित करना चाहिए के लिए कॉल Task (IronPython निष्पादन)

क्या हम क्या करना चाहते हैं इंतज़ार कर रहे राज्य के लिए:

1. हम अनंत लूप, जो Task रों कतार
2. के माध्यम से पुनरावृति जब हम एक Task मिल हम इसे
3. PythonScript हम सी # विधि कॉल और राज्य इंतजार कर के लिए इस स्क्रिप्ट स्थानांतरित करना चाहते हैं पर अमल करने की कोशिश करेंगे बनाना चाहते हैं। लेकिन कतार से इसे हटा नहीं है।
4. अगले पुनरावृत्ति पर जब हमें एक और Task मिलता है तो हम प्रतीक्षा स्थिति में जांचते हैं। यदि ऐसा है तो हम इसे जगाते हैं और निष्पादित करने का प्रयास करते हैं।
5. प्रत्येक क्षण में हम केवल एक सक्रिय Task
6. होना चाहिए और अंत में हम को मापने के लिए कितने Task हम प्रति सेकंड

मैं वास्तव में नहीं जानता कि यह सहकारी मल्टीटास्किंग के बारे में कुछ है पर अमल कर सकता हैं? हम कस्टम TaskScheduler के बारे में सोच रहे हैं, क्या यह अच्छा दृष्टिकोण है? या कोई बेहतर समाधान जानता है?

धन्यवाद।

अपडेट किया गया:

ठीक है, तो उदाहरण के लिए, मैं इस तरह के कोड है:

एक _thread टास्क निष्पादन और कार्य चलाने के लिए _currentTask क्षेत्र के लिए, यह भी SleepCurrentTask है

public class CooperativeScheduler : TaskScheduler, IDisposable 
    { 
     private BlockingCollection<Task> _tasks; 

     private Thread _thread; 

     private Task _currentTask; 

     public CooperativeScheduler() 
     { 
      this._tasks = new BlockingCollection<Task>(); 
      this._thread = new Thread(() => 
       { 
        foreach (Task task in this._tasks.GetConsumingEnumerable()) 
        { 
         this._currentTask = task; 

         TryExecuteTask(this._currentTask); 
        } 
       } 
      ); 

      this._thread.Name = "Cooperative scheduler thread"; 

      this._thread.Start(); 
     } 

     public void SleepCurrentTask() 
     { 
      if (this._currentTask != null) 
      { 
       // what to do here? 
      } 
     } 

     protected override IEnumerable<Task> GetScheduledTasks() 
     { 
      return this._tasks.ToArray<Task>(); 
     } 

     protected override void QueueTask(Task task) 
     { 
      // No long task 
      this._tasks.Add(task); 
     } 

     protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) 
     { 
      throw new NotImplementedException(); 
     } 

     public void Dispose() 
     { 
      this._tasks.CompleteAdding(); 
      this._thread.Join(); 
     } 
    } 

कस्टम कार्य शेड्यूलर, यह है इस विधि में मैं वर्तमान कार्य निष्पादन को निलंबित करना चाहता हूं, लेकिन मुझे नहीं पता कि कैसे।

क्लाइंट कोड सरल है:

CancellationTokenSource tokenSource = new CancellationTokenSource(); 
    Application app = Application.Create(); 


    Task task = Task.Factory.StartNew(() => 
    { 
     app.Scheduler.SleepCurrentTask(); 
    }, 
    tokenSource.Token, TaskCreationOptions.None, app.Scheduler); 
} 

बेहतर विचार हो सकता है कि कोई है?

Answer 1

ऐसा लगता है कि आपको निर्माता/उपभोक्ता पैटर्न का उपयोग करने के लिए अच्छी तरह से सेवा दी जाएगी .NET 4 ने कुछ संग्रहों में बनाया है।

माइक्रोसॉफ्ट से इस मुफ्त पीडीएफ में पृष्ठ 55 देखें, Patterns of Parallel Programming