Python में SimPy का उपयोग करके डिस्क्रीट इवेंट सिमुलेशन की मूल बातें

SimPy ("Blimpie" के साथ तुकबंदी) प्रक्रिया-उन्मुख डिस्क्रीट-इवेंट सिमुलेशन के लिए एक Python पैकेज है।

इंस्टॉलेशन

SimPy इंस्टॉल करने का सबसे आसान तरीका pip के माध्यम से है:

pip install simpy

और आपको ऐसा आउटपुट मिल सकता है,

लेखन के समय, simpy-3.0.11 SimPy का सबसे हालिया संस्करण है, और हम नीचे दिए गए सभी उदाहरणों के लिए इसका उपयोग करेंगे।

यदि SimPy पहले से इंस्टॉल है, तो pip के लिए -U विकल्प का उपयोग करके अपग्रेड करें।

pip install --U simpy

नोट: आपको Python 2.7 या उच्चतर संस्करण की आवश्यकता है और Linux/Unix/MacOS के लिए आपको SimPy इंस्टॉल करने के लिए रूट विशेषाधिकारों की आवश्यकता हो सकती है।

जांचने के लिए कि SimPy सफलतापूर्वक इंस्टॉल हुआ है या नहीं, एक Python शेल खोलें और simpy आयात करें।

मूल अवधारणाएं

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

जब एक प्रक्रिया एक इवेंट देती है, तो प्रक्रिया निलंबित हो जाती है। SimPy हमें निलंबित प्रक्रिया को फिर से शुरू करने की अनुमति देता है जब भी इवेंट ट्रिगर होता है। यदि कई प्रक्रियाएं एक ही इवेंट की प्रतीक्षा करती हैं, तो SimPy उन्हें उसी क्रम में फिर से शुरू करता है जिसमें उन्होंने उस इवेंट को yield किया था।

def gen(x):
    y = yield x+1
    return y

>>> g = gen(1)
>>> next(g)
2
>>> next(g)
Traceback (most recent call last):
  File "", line 1, in 
    next(g)
StopIteration

उपरोक्त पुनरावृत्ति वेरिएबल x के पहले yield के बाद रुक जाती है।

Timeout प्रकार के इवेंट एक निश्चित मात्रा में (सिम्युलेटेड) समय बीत जाने के बाद ट्रिगर होते हैं। Timeout इवेंट एक प्रक्रिया को एक निश्चित समय के लिए रोकने या सोने की अनुमति देता है। Timeout सहित सभी इवेंट, Environment के उपयुक्त मेथड को कॉल करके बनाए जा सकते हैं जिसमें प्रक्रिया रहती है।

# महत्वपूर्ण लाइब्रेरी आयात करें
from random import randint
import simpy

# कॉन्फ़िगरेशन
TALKS_PER_SESSION = 3
TALK_LENGTH = 30
BREAK_LENGTH = 15
ATTENDEES = 1

def attendee(env, name, knowledge=0, hunger=0):
    talks = 0
    breaks = 0
    
    # सत्र दोहराएं
    while True:
        # वार्ता में भाग लें
        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))
        
        # ब्रेक लें, बुफे पर जाएं
        food = randint(3, 12)
        hunger -= min(food, hunger)
        yield env.timeout(BREAK_LENGTH)
        print('Attendee %s finished eating with hunger %.2f' % (name, hunger))

# सिमुलेशन चलाएं
env = simpy.Environment()
for i in range(ATTENDEES):
    env.process(attendee(env, i))
env.run(until=250)

यदि हम उपरोक्त प्रोग्राम चलाते हैं, तो हमें ऐसा आउटपुट दिखाई देगा,

ऊपर हम कॉन्फ्रेंस हॉल परिदृश्य को दोहराने का प्रयास करते हैं, जहां प्रति सत्र 4 वार्ता के साथ यादृच्छिक संख्या में स्पीकर हैं जिनकी वार्ता लंबाई 40 मिनट और ब्रेक लंबाई 30 मिनट है।

हमारी अटेंडी प्रक्रिया को नए इवेंट बनाने के लिए Environment (env), नाम, ज्ञान और भूख के संदर्भ की आवश्यकता होती है। सत्र अनंत लूप में तब तक चलेंगे जब तक यह False नहीं हो जाता। attendee() फ़ंक्शन एक जेनरेटर है जो समाप्त नहीं होगा लेकिन yield स्टेटमेंट पहुंचने पर नियंत्रण प्रवाह को सिमुलेशन पर वापस कर देगा।

अंत में, हम 250 के एक निर्धारित मान तक एक डेमो सिमुलेशन 'कॉन्फ्रेंस अटेंडी' चलाते हैं (इसमें शामिल हैं - 3 वार्ता, 1 ब्रेक, 3 वार्ता, 1 ब्रेक, 1 वार्ता)।