2009-12-25 8 views
13

से जीयूआई प्रक्रिया को अलग मैं कंप्यूटर सिमुलेशन से निपटने के लिए एक Python project विकासशील रहा हूँ, और मैं भी इसके लिए एक जीयूआई के विकास कर रहा हूँ। (कोर तर्क अपने आप में एक जीयूआई की आवश्यकता नहीं है।) जीयूआई टूलकिट मैं के लिए उपयोग wxPython है, लेकिन मुझे लगता है कि मेरे सवाल का पर्याप्त उस पर निर्भर करने के लिए नहीं सामान्य है।पायथन: कोर तर्क प्रक्रिया

जिस तरह से जीयूआई वर्तमान में काम करता है वह यह है कि यह उसी प्रक्रिया पर कोर लॉजिक पैकेज (जिसे garlicsim कहा जाता है) और जीयूआई के समान धागा शुरू होता है। यह काम करता है, लेकिन मैं समझता हूँ कि यह एक समस्या पैदा करने वाले दृष्टिकोण है, क्योंकि कोर तर्क कुछ कठिन गणना करने की जरूरत है, जीयूआई, रखती हूँ जो मुझे अस्वीकार्य पर विचार करें।

मुझे क्या करना चाहिए?

मैं जीयूआई से अलग प्रक्रिया पर कोर तर्क शुरू करने का विकल्प के बारे में सुना। यह दिलचस्प लगता है, लेकिन मेरे पास इसके बारे में बहुत सारे प्रश्न हैं।

  1. मैं multiprocessing पैकेज या नई प्रक्रिया शुरू करने के लिए subprocess पैकेज का उपयोग करते हैं?
  2. मैं जीयूआई प्रक्रिया से सिम्युलेशन डेटा तक आसानी से पहुँचा कैसे है? आखिरकार, यह दूसरी प्रक्रिया पर संग्रहीत किया जाएगा। उपयोगकर्ता आसानी से और सुचारू रूप से सिमुलेशन के समय के माध्यम से ब्राउज़ करने के लिए सक्षम होना चाहिए। यह कैसे किया जा सकता है?

उत्तर

6

आप कुछ प्रेरणा यहां मिल सकती है: http://wiki.wxpython.org/LongRunningTasks, लेकिन यह बहु सूत्रण के लिए है, बहु नहीं।

मूल विचार

    बहु सूत्रण के लिए
  • : जीयूआई और प्रसंस्करण धागा के बीच संवाद की एक घटना कतार का उपयोग करें। मल्टीप्रोसेसिंग के लिए
  • : शायद सबप्रोसेस पैकेज का उपयोग करें, और इसके साथ संवाद करने के लिए बाल प्रक्रिया के stdin/stdout का उपयोग करें। इसके लिए आपको कमांड लाइन एपीआई की आवश्यकता है, लेकिन यह अंततः आसान होगा, क्योंकि आप गुई-स्वतंत्र इकाई परीक्षण कर सकते हैं।

आप सॉकेट के माध्यम से आई/ओ संचार भी चला सकते हैं, इससे सिमुलेशन के आसान नेटवर्क प्रबंधन को छोड़ दिया जाएगा।

संपादित करें: मैं सिर्फ देखा 2.6 नई पैकेज आप का उल्लेख बहु। एक अच्छा चयन लगता है, आप प्रक्रिया के बीच संवाद करने के लिए कतार का उपयोग कर सकते हैं। यह एक कठिन युग्मन है, आप अपनी जरूरतों के आधार पर चुन सकते हैं।

+0

'सबप्रोकैसिंग' पैकेज द्वारा मुझे लगता है कि आपका मतलब 'उपप्रोसेस' है, है ना? – Kylotan

+0

@ किलोटन: हाँ, सही, धन्यवाद – ron

1

दुर्भाग्य से, हालांकि आप सही है कि जीयूआई की पसंद जवाब को प्रभावित नहीं करता हो, इस समस्या का सबसे अच्छा तरीका बिल्कुल अपने सिम्युलेशन डेटा क्या कर रहा है पर बहुत कुछ निर्भर करेगा।

उदाहरण के लिए, अगर यह अनुक्रमिक डेटा तो उत्पन्न करता है यह यह आपके जीयूआई के लिए एक धागा सुरक्षित या प्रक्रिया सुरक्षित कतार के माध्यम से फ़ीड कर सकते हैं। लेकिन अगर यह पूरे डेटा mutates और अपने जीयूआई किसी भी समय एक स्नैपशॉट देखने के लिए सक्षम होने की जरूरत है, वह भी कतार के साथ पूरे राज्य भेजकर हल करने के लिए महंगा हो सकता है और पहुंच साझा करने के बजाय एक म्युटेक्स शैली दृष्टिकोण की आवश्यकता हो सकती डेटा संरचना के लिए। तो आपके डेटा पर किए गए काम की प्रकृति यहां सर्वोपरि है। चाहे बहु या उपप्रक्रिया का उपयोग करने के लिए

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

2

विशिष्ट प्रश्नों के उत्तर देने के लिए ।

"क्या मैं नई प्रक्रिया लॉन्च करने के लिए multiprocessing पैकेज या subprocess पैकेज का उपयोग करता हूं?"

उपयोग multiprocessing

"मैं जीयूआई प्रक्रिया से सिम्युलेशन डेटा के लिए आसान पहुँच है?"

यदि आप यही पूछ रहे हैं तो सिमुलेशन प्रक्रिया वस्तुओं तक पहुंच नहीं है, सिमुलेशन एक अलग प्रक्रिया है। आप इसे शुरू कर सकते हैं, इसे रोक सकते हैं, और - सबसे महत्वपूर्ण बात - सिम्युलेटर पर जाने वाले आदेशों की कतार के माध्यम से अनुरोध करें।

"उपयोगकर्ता सिमुलेशन की समयरेखा को आसानी से और आसानी से ब्राउज़ करने में सक्षम होना चाहिए। यह कैसे किया जा सकता है?"

यह सिर्फ डिज़ाइन है। एकल प्रक्रिया, एकाधिक प्रक्रियाओं, एकाधिक धागे का इस प्रश्न पर कोई असर नहीं पड़ता है।

प्रत्येक सिमुलेशन में कुछ पैरामीटर होना चाहिए, इसे शुरू करना होगा, इसे एक लॉग (या टाइमलाइन) बनाना होगा। सिमुलेशन शुरू करने और रोकने के लिए आप जिस लाइब्रेरी का उपयोग करते हैं, इससे कोई फर्क नहीं पड़ता है।

सिमुलेशन से आउटपुट - जो आपके जीयूआई में इनपुट है - को दस लाख तरीकों से किया जा सकता है।

  • डेटाबेस। सिमुलेशन टाइमलाइन को SQLite डेटाबेस में डाला जा सकता है और जीयूआई द्वारा पूछताछ की जा सकती है। यह बहुत अच्छी तरह से काम नहीं करता है क्योंकि SQLite वास्तव में चालाक लॉकिंग नहीं है। लेकिन यह काम करता है।

  • फ़ाइल। सिमुलेशन टाइमलाइन एक फाइल में लिखा गया है। जीयूआई फाइल पढ़ता है। यह वास्तव में वास्तव में अच्छी तरह से काम करता है।

  • अनुरोध/उत्तर। उदाहरण के लिए - - वापस पल अप करने के लिए भेजने के समय, या अनुकरण रोक या पैरामीटर बदल रहा है और यह पुन: प्रारंभ अनुकरण से अधिक थ्रेड, जिनमें से एक आदेशों dequeueing जाता है और द्वारा जवाब नहीं है।

2

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

अन्य समाधान अधिक जटिल हैं - आप एक पूरी तरह से अलग "सर्वर" इस ​​प्रक्रिया में सिमुलेशन चल अंत और मुख्य जीयूआई के साथ सॉकेट के साथ संवाद कर सकते हैं।

0
वितरित डेटा वस्तुओं के साथ

Mutiprocessing या Pyro।

http://pyro.sourceforge.net/

आपका अनुकरण आपूर्ति जीयूआई वस्तुओं वितरित, जीयूआई उन्हें manipulates और उनकी विशेषताओं पढ़ता है।

दोनों पुस्तकालय बिना किसी परेशानी के नेटवर्क पर विस्तारशीलता प्रदान करेंगे, लेकिन स्थानीय रूप से चला सकते हैं। जब आपका सिमुलेशन बहुत अधिक संख्याओं को क्रंच करना शुरू करता है, तो अधिक सिमुलेशन सर्वर जोड़ें जो अधिक वितरित ऑब्जेक्ट प्रदान करते हैं।