SimPy ("ब्लिम्पी" के साथ गाया जाता है) प्रक्रिया-उन्मुख असतत-घटना सिमुलेशन के लिए एक अजगर पैकेज है।
इंस्टॉलेशन
सिमपी को स्थापित करने का सबसे आसान तरीका पाइप के माध्यम से है:
pip install simpy
और आपको जो आउटपुट मिल सकता है वह कुछ इस तरह होगा,
लेखन के समय, simpy-3.0.11, SimPy का नवीनतम संस्करण है, और हम नीचे दिए गए सभी उदाहरणों के लिए इसका उपयोग करेंगे।
यदि सिमपी पहले से स्थापित है, तो पाइप को अपग्रेड करने के लिए –यू विकल्प का उपयोग करें।
pip install –U simpy
नोट :आपके पास अजगर 2.7 या उससे ऊपर का संस्करण होना चाहिए और Linux/Unix/MacOS के लिए आपको SimPy को स्थापित करने के लिए रूट विशेषाधिकारों की आवश्यकता हो सकती है।
यह जाँचने के लिए कि क्या SimPy सफलतापूर्वक स्थापित किया गया था, एक अजगर खोल खोलें और simpy आयात करें।
मूल अवधारणाएं
SimPy, जो एक असतत-घटना सिमुलेशन पुस्तकालय है। सिम्पी के सक्रिय घटक (जैसे संदेश, वाहन या ग्राहक) प्रक्रियाओं के साथ तैयार किए जाते हैं। सिमपी में, सक्रिय संस्थाओं को प्रक्रियाओं के रूप में जाना जाता है। एक प्रक्रिया एक पायथन जनरेटर है जो असतत घटनाओं को उत्पन्न करती है। कृपया ध्यान दें, मैं कुछ भी वापस नहीं कर रहा हूं, लेकिन मैं एक उपज (आईएनजी) हूं, जो कि सामान्य फ़ंक्शन और जनरेटर के बीच का अंतर है। यह हमें ईवेंट बनाने और उनके ट्रिगर होने की प्रतीक्षा करने के लिए उन्हें प्रस्तुत करने की अनुमति देता है।
जब कोई प्रक्रिया एक घटना उत्पन्न करती है, तो प्रक्रिया निलंबित हो जाती है। जब भी ईवेंट ट्रिगर होता है तो SimPy हमें निलंबित प्रक्रिया को फिर से शुरू करने की अनुमति देता है। यदि कई प्रक्रियाएं एक ही घटना की प्रतीक्षा करती हैं, तो सिमपी उन्हें उसी क्रम में फिर से शुरू करता है जिसमें वे उस घटना को प्राप्त करते हैं।
def gen(x): y = yield x+1 return y
>>> g = gen(1) >>> next(g) 2 >>> next(g) Traceback (most recent call last): File "<pyshell#2>", line 1, in <module> next(g) StopIteration
चर x पहली उपज के बाद उपरोक्त पुनरावृत्ति बंद हो जाती है।
टाइमआउट प्रकार की घटनाओं को एक निश्चित मात्रा (सिम्युलेटेड) समय बीत जाने के बाद ट्रिगर किया जाता है। टाइमआउट इवेंट एक प्रक्रिया को एक निश्चित समय के लिए रुकने या सोने की अनुमति देता है। टाइमआउट सहित सभी घटनाओं को पर्यावरण की उपयुक्त विधि को कॉल करके बनाया जा सकता है जिसमें प्रक्रिया रहती है।
#Import important library
from random import randint
import simpy
#Config
TALKS_PER_SESSION = 3
TALK_LENGTH = 30
BREAK_LENGTH = 15
ATTENDEES = 1
def attendee(env, name, knowledge=0, hunger=0):
talks =0
breaks =0
#Repeat sessions
while True:
# Visit talks
for i in range(TALKS_PER_SESSION):
print('Talk {0} begins at {1}'.format(talks+1, env.now))
knowledge += randint(0, 3) / (1 + hunger)
hunger += randint(1, 4)
talks += 1
yield env.timeout(TALK_LENGTH)
print(f'Talk {talks} ends at {env.now}')
print('Attendee %s finished talks with knowledge %.2f and hunger ' '%.2f' %( name, knowledge, hunger))
#Take a break, Go to buffet
food = randint(3, 12)
hunger -= min(food, hunger)
yield env.timeout(BREAK_LENGTH)
print('Attendee %s finished eating with hunger %.2f ' %(name, hunger))
# Run Simulation
env = simpy.Environment()
for i in range(ATTENDEES):
env.process(attendee(env, i))
env.run(until=250) यदि हम उपरोक्त प्रोग्राम चलाते हैं, तो हमें आउटपुट कुछ इस तरह दिखाई देगा,
ऊपर हम कॉन्फ़्रेंस हॉल के परिदृश्य को दोहराने की कोशिश करते हैं, जहाँ 40 मिनट की टॉक लेंथ और 30 मिनट की लंबाई के ब्रेक के साथ 4 के प्रति सत्र में बोलने वालों की एक यादृच्छिक संख्या होती है।
नई घटनाओं को बनाने के लिए हमारी सहभागी प्रक्रिया को एक पर्यावरण (env), नाम, ज्ञान और भूख के संदर्भ की आवश्यकता होती है। सत्र एक अनंत लूप में तब तक चलेगा जब तक यह गलत नहीं हो जाता। सहभागी () फ़ंक्शन एक जनरेटर है जो समाप्त नहीं होगा लेकिन एक बार उपज विवरण तक पहुंचने के बाद नियंत्रण प्रवाह को सिमुलेशन में वापस भेज देगा।
अंत में, हम एक डेमो सिम्युलेशन 'कॉन्फ्रेंस अटेंडी' चलाते हैं, जब तक कि 250 का एक सेट वैल्यू तक नहीं पहुंच जाता (इसमें शामिल हैं- 3 वार्ता, 1 ब्रेक, 3 वार्ता, 1 ब्रेक, 1 टॉक)।