ग्लोबल इंटरप्रेटर लॉक (GIL): समवर्ती सीमाओं का एक व्यापक विश्लेषण

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

ग्लोबल इंटरप्रेटर लॉक (GIL) क्या है?

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

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

GIL को क्यों प्रस्तुत किया गया था?

• मेमोरी मैनेजमेंट: पाइथन के शुरुआती संस्करणों में मेमोरी प्रबंधन के लिए रेफरेंस काउंटिंग का उपयोग किया जाता था। GIL के बिना, इन रेफरेंस काउंट्स को थ्रेड-सुरक्षित तरीके से प्रबंधित करना जटिल और कम्प्यूटेशनल रूप से महंगा होता, जिससे संभावित रूप से रेस कंडीशन और मेमोरी करप्शन हो सकता था।
• सरलीकृत C एक्सटेंशन: GIL ने C एक्सटेंशन को पाइथन के साथ एकीकृत करना आसान बना दिया। कई पाइथन लाइब्रेरी, विशेष रूप से वैज्ञानिक कंप्यूटिंग से संबंधित (जैसे NumPy), प्रदर्शन के लिए C कोड पर बहुत अधिक निर्भर करती हैं। GIL ने पाइथन से C कोड को कॉल करते समय थ्रेड सुरक्षा सुनिश्चित करने का एक सीधा तरीका प्रदान किया।

समवर्तीता पर GIL का प्रभाव

GIL मुख्य रूप से सीपीयू-बाउंड कार्यों को प्रभावित करता है। सीपीयू-बाउंड कार्य वे होते हैं जो अपना अधिकांश समय I/O संचालन (जैसे, नेटवर्क अनुरोध, डिस्क रीड) की प्रतीक्षा करने के बजाय गणना करने में बिताते हैं। उदाहरणों में इमेज प्रोसेसिंग, संख्यात्मक गणना और जटिल डेटा रूपांतरण शामिल हैं। सीपीयू-बाउंड कार्यों के लिए, GIL सच्ची समांतरता को रोकता है, क्योंकि किसी भी समय केवल एक थ्रेड सक्रिय रूप से पाइथन कोड निष्पादित कर सकता है। इससे मल्टी-कोर सिस्टम पर खराब स्केलिंग हो सकती है।

हालांकि, GIL का I/O-बाउंड कार्यों पर कम प्रभाव पड़ता है। I/O-बाउंड कार्य अपना अधिकांश समय बाहरी संचालन के पूरा होने की प्रतीक्षा में बिताते हैं। जबकि एक थ्रेड I/O की प्रतीक्षा कर रहा होता है, GIL को जारी किया जा सकता है, जिससे अन्य थ्रेड्स को निष्पादित करने की अनुमति मिलती है। इसलिए, मल्टी-थ्रेडेड एप्लिकेशन जो मुख्य रूप से I/O-बाउंड हैं, वे GIL के साथ भी समवर्तीता से लाभ उठा सकते हैं।

उदाहरण के लिए, कई क्लाइंट अनुरोधों को संभालने वाले एक वेब सर्वर पर विचार करें। प्रत्येक अनुरोध में डेटाबेस से डेटा पढ़ना, बाहरी API कॉल करना, या किसी फ़ाइल में डेटा लिखना शामिल हो सकता है। ये I/O संचालन GIL को जारी करने की अनुमति देते हैं, जिससे अन्य थ्रेड्स को समवर्ती रूप से अन्य अनुरोधों को संभालने में सक्षम बनाया जा सकता है। इसके विपरीत, एक प्रोग्राम जो बड़े डेटासेट पर जटिल गणितीय गणना करता है, वह GIL द्वारा गंभीर रूप से सीमित होगा।

सीपीयू-बाउंड बनाम I/O-बाउंड कार्यों को समझना

सीपीयू-बाउंड और I/O-बाउंड कार्यों के बीच अंतर करना GIL के प्रभाव को समझने और उचित समवर्ती रणनीति चुनने के लिए महत्वपूर्ण है।

सीपीयू-बाउंड कार्य

• परिभाषा: ऐसे कार्य जहां सीपीयू अपना अधिकांश समय गणना करने या डेटा संसाधित करने में व्यतीत करता है।
• विशेषताएँ: उच्च सीपीयू उपयोग, बाहरी संचालन के लिए न्यूनतम प्रतीक्षा।
• उदाहरण: इमेज प्रोसेसिंग, वीडियो एन्कोडिंग, संख्यात्मक सिमुलेशन, क्रिप्टोग्राफिक ऑपरेशन।
• GIL का प्रभाव: कई कोर पर समानांतर में पाइथन कोड निष्पादित करने में असमर्थता के कारण महत्वपूर्ण प्रदर्शन बाधा।

I/O-बाउंड कार्य

• परिभाषा: ऐसे कार्य जहां प्रोग्राम अपना अधिकांश समय बाहरी संचालन के पूरा होने की प्रतीक्षा में व्यतीत करता है।
• विशेषताएँ: कम सीपीयू उपयोग, I/O संचालन (नेटवर्क, डिस्क, आदि) के लिए बार-बार प्रतीक्षा।
• उदाहरण: वेब सर्वर, डेटाबेस इंटरैक्शन, फ़ाइल I/O, नेटवर्क संचार।
• GIL का प्रभाव: कम महत्वपूर्ण प्रभाव क्योंकि I/O की प्रतीक्षा करते समय GIL जारी किया जाता है, जिससे अन्य थ्रेड्स को निष्पादित करने की अनुमति मिलती है।

GIL सीमाओं को कम करने की रणनीतियाँ

GIL द्वारा लगाई गई सीमाओं के बावजूद, पाइथन और अन्य GIL-प्रभावित भाषाओं में समवर्तीता और समांतरता प्राप्त करने के लिए कई रणनीतियों को नियोजित किया जा सकता है।

1. मल्टीप्रोसेसिंग

मल्टीप्रोसेसिंग में कई अलग-अलग प्रक्रियाएं बनाना शामिल है, जिनमें से प्रत्येक का अपना पाइथन इंटरप्रेटर और मेमोरी स्पेस होता है। यह GIL को पूरी तरह से बायपास करता है, जिससे मल्टी-कोर सिस्टम पर सच्ची समांतरता की अनुमति मिलती है। पाइथन में `multiprocessing` मॉड्यूल प्रक्रियाओं को बनाने और प्रबंधित करने का एक सीधा तरीका प्रदान करता है।

उदाहरण:

            import multiprocessing

def worker(num):
 print(f"Worker {num}: Starting")
 # Perform some CPU-bound task
 result = sum(i * i for i in range(1000000))
 print(f"Worker {num}: Finished, Result = {result}")

if __name__ == '__main__':
 processes = []
 for i in range(4):
 p = multiprocessing.Process(target=worker, args=(i,))
 processes.append(p)
 p.start()

 for p in processes:
 p.join()

 print("All workers finished")

            

              
                Copy
              
            
          

लाभ:

• मल्टी-कोर सिस्टम पर सच्ची समांतरता।
• GIL की सीमा को बायपास करता है।
• सीपीयू-बाउंड कार्यों के लिए उपयुक्त।

नुकसान:

• अलग-अलग मेमोरी स्पेस के कारण उच्च मेमोरी ओवरहेड।
• इंटर-प्रोसेस संचार इंटर-थ्रेड संचार की तुलना में अधिक जटिल हो सकता है।
• प्रक्रियाओं के बीच डेटा का सीरियलाइजेशन और डीसीरियलाइजेशन ओवरहेड जोड़ सकता है।

2. एसिंक्रोनस प्रोग्रामिंग (asyncio)

एसिंक्रोनस प्रोग्रामिंग एक एकल थ्रेड को I/O संचालन की प्रतीक्षा करते समय कई समवर्ती कार्यों के बीच स्विच करके उन्हें संभालने की अनुमति देती है। पाइथन में `asyncio` लाइब्रेरी कोरूटीन और इवेंट लूप का उपयोग करके एसिंक्रोनस कोड लिखने के लिए एक ढाँचा प्रदान करती है।

उदाहरण:

            import asyncio
import aiohttp

async def fetch_url(url):
 async with aiohttp.ClientSession() as session:
 async with session.get(url) as response:
 return await response.text()

async def main():
 urls = [
 "https://www.example.com",
 "https://www.google.com",
 "https://www.python.org"
 ]

 tasks = [fetch_url(url) for url in urls]
 results = await asyncio.gather(*tasks)

 for i, result in enumerate(results):
 print(f"Content from {urls[i]}: {result[:50]}...") # Print the first 50 characters

if __name__ == '__main__':
 asyncio.run(main())

            

              
                Copy
              
            
          

लाभ:

• I/O-बाउंड कार्यों का कुशल संचालन।
• मल्टीप्रोसेसिंग की तुलना में कम मेमोरी ओवरहेड।
• नेटवर्क प्रोग्रामिंग, वेब सर्वर और अन्य एसिंक्रोनस एप्लिकेशन के लिए उपयुक्त।

नुकसान:

• सीपीयू-बाउंड कार्यों के लिए सच्ची समांतरता प्रदान नहीं करता है।
• अवरुद्ध संचालन से बचने के लिए सावधानीपूर्वक डिजाइन की आवश्यकता होती है जो इवेंट लूप को रोक सकते हैं।
• पारंपरिक मल्टी-थ्रेडिंग की तुलना में इसे लागू करना अधिक जटिल हो सकता है।

3. Concurrent.futures

`concurrent.futures` मॉड्यूल थ्रेड्स या प्रक्रियाओं का उपयोग करके एसिंक्रोनस रूप से कॉलेबल को निष्पादित करने के लिए एक उच्च-स्तरीय इंटरफ़ेस प्रदान करता है। यह आपको आसानी से कार्यों को श्रमिकों के एक पूल में जमा करने और उनके परिणामों को भविष्य के रूप में प्राप्त करने की अनुमति देता है।

उदाहरण (थ्रेड-आधारित):

            from concurrent.futures import ThreadPoolExecutor
import time

def task(n):
 print(f"Task {n}: Starting")
 time.sleep(1) # Simulate some work
 print(f"Task {n}: Finished")
 return n * 2

if __name__ == '__main__':
 with ThreadPoolExecutor(max_workers=3) as executor:
 futures = [executor.submit(task, i) for i in range(5)]

 results = [future.result() for future in futures]
 print(f"Results: {results}")

            

              
                Copy
              
            
          

उदाहरण (प्रक्रिया-आधारित):

            from concurrent.futures import ProcessPoolExecutor
import time

def task(n):
 print(f"Task {n}: Starting")
 time.sleep(1) # Simulate some work
 print(f"Task {n}: Finished")
 return n * 2

if __name__ == '__main__':
 with ProcessPoolExecutor(max_workers=3) as executor:
 futures = [executor.submit(task, i) for i in range(5)]

 results = [future.result() for future in futures]
 print(f"Results: {results}")

            

              
                Copy
              
            
          

लाभ:

• थ्रेड्स या प्रक्रियाओं के प्रबंधन के लिए सरलीकृत इंटरफ़ेस।
• थ्रेड-आधारित और प्रक्रिया-आधारित समवर्तीता के बीच आसान स्विचिंग की अनुमति देता है।
• एक्ज़ीक्यूटर प्रकार के आधार पर, सीपीयू-बाउंड और I/O-बाउंड दोनों कार्यों के लिए उपयुक्त।

नुकसान:

• थ्रेड-आधारित निष्पादन अभी भी GIL सीमाओं के अधीन है।
• प्रक्रिया-आधारित निष्पादन में उच्च मेमोरी ओवरहेड होता है।

4. C एक्सटेंशन और नेटिव कोड

GIL को बायपास करने के सबसे प्रभावी तरीकों में से एक है सीपीयू-गहन कार्यों को C एक्सटेंशन या अन्य नेटिव कोड पर ऑफ़लोड करना। जब इंटरप्रेटर C कोड निष्पादित कर रहा होता है, तो GIL को जारी किया जा सकता है, जिससे अन्य थ्रेड्स समवर्ती रूप से चल सकते हैं। यह आमतौर पर NumPy जैसी लाइब्रेरी में उपयोग किया जाता है, जो GIL को जारी करते हुए C में संख्यात्मक गणना करती हैं।

उदाहरण: NumPy, वैज्ञानिक कंप्यूटिंग के लिए व्यापक रूप से उपयोग की जाने वाली पाइथन लाइब्रेरी, अपने कई कार्यों को C में लागू करती है, जो इसे GIL द्वारा सीमित किए बिना समानांतर गणना करने की अनुमति देती है। यही कारण है कि NumPy का उपयोग अक्सर मैट्रिक्स गुणन और सिग्नल प्रोसेसिंग जैसे कार्यों के लिए किया जाता है, जहां प्रदर्शन महत्वपूर्ण होता है।

लाभ:

• सीपीयू-बाउंड कार्यों के लिए सच्ची समांतरता।
• शुद्ध पाइथन कोड की तुलना में प्रदर्शन में काफी सुधार कर सकता है।

नुकसान:

• C कोड लिखने और बनाए रखने की आवश्यकता होती है, जो पाइथन की तुलना में अधिक जटिल हो सकता है।
• परियोजना की जटिलता को बढ़ाता है और बाहरी पुस्तकालयों पर निर्भरता का परिचय देता है।
• इष्टतम प्रदर्शन के लिए प्लेटफ़ॉर्म-विशिष्ट कोड की आवश्यकता हो सकती है।

5. वैकल्पिक पाइथन कार्यान्वयन

कई वैकल्पिक पाइथन कार्यान्वयन मौजूद हैं जिनमें GIL नहीं है। ये कार्यान्वयन, जैसे कि Jython (जो जावा वर्चुअल मशीन पर चलता है) और IronPython (जो .NET फ्रेमवर्क पर चलता है), विभिन्न समवर्ती मॉडल प्रदान करते हैं और GIL की सीमाओं के बिना सच्ची समांतरता प्राप्त करने के लिए उपयोग किए जा सकते हैं।

हालांकि, इन कार्यान्वयनों में अक्सर कुछ पाइथन पुस्तकालयों के साथ संगतता संबंधी समस्याएं होती हैं और यह सभी परियोजनाओं के लिए उपयुक्त नहीं हो सकते हैं।

लाभ:

• GIL सीमाओं के बिना सच्ची समांतरता।
• जावा या .NET पारिस्थितिकी तंत्र के साथ एकीकरण।

नुकसान:

• पाइथन पुस्तकालयों के साथ संभावित संगतता समस्याएं।
• CPython की तुलना में विभिन्न प्रदर्शन विशेषताएँ।
• CPython की तुलना में छोटा समुदाय और कम समर्थन।

वास्तविक-दुनिया के उदाहरण और केस स्टडीज

आइए GIL के प्रभाव और विभिन्न शमन रणनीतियों की प्रभावशीलता को दर्शाने के लिए कुछ वास्तविक-दुनिया के उदाहरणों पर विचार करें।

केस स्टडी 1: इमेज प्रोसेसिंग एप्लिकेशन

एक इमेज प्रोसेसिंग एप्लिकेशन छवियों पर विभिन्न ऑपरेशन करता है, जैसे फ़िल्टरिंग, आकार बदलना और रंग सुधार। ये ऑपरेशन सीपीयू-बाउंड हैं और कम्प्यूटेशनल रूप से गहन हो सकते हैं। CPython के साथ मल्टी-थ्रेडिंग का उपयोग करके एक भोले-भाले कार्यान्वयन में, GIL सच्ची समांतरता को रोक देगा, जिसके परिणामस्वरूप मल्टी-कोर सिस्टम पर खराब स्केलिंग होगी।

समाधान: इमेज प्रोसेसिंग कार्यों को कई प्रक्रियाओं में वितरित करने के लिए मल्टीप्रोसेसिंग का उपयोग करने से प्रदर्शन में काफी सुधार हो सकता है। प्रत्येक प्रक्रिया एक अलग छवि पर या एक ही छवि के एक अलग हिस्से पर समवर्ती रूप से काम कर सकती है, जिससे GIL की सीमा को बायपास किया जा सकता है।

केस स्टडी 2: API अनुरोधों को संभालने वाला वेब सर्वर

एक वेब सर्वर कई API अनुरोधों को संभालता है जिनमें डेटाबेस से डेटा पढ़ना और बाहरी API कॉल करना शामिल है। ये ऑपरेशन I/O-बाउंड हैं। इस मामले में, `asyncio` के साथ एसिंक्रोनस प्रोग्रामिंग का उपयोग करना मल्टी-थ्रेडिंग की तुलना में अधिक कुशल हो सकता है। सर्वर I/O संचालन के पूरा होने की प्रतीक्षा करते समय उनके बीच स्विच करके कई अनुरोधों को समवर्ती रूप से संभाल सकता है।

केस स्टडी 3: वैज्ञानिक कंप्यूटिंग एप्लिकेशन

एक वैज्ञानिक कंप्यूटिंग एप्लिकेशन बड़े डेटासेट पर जटिल संख्यात्मक गणना करता है। ये गणनाएँ सीपीयू-बाउंड हैं और उच्च प्रदर्शन की आवश्यकता होती है। NumPy का उपयोग करना, जो अपने कई कार्यों को C में लागू करता है, गणना के दौरान GIL को जारी करके प्रदर्शन में काफी सुधार कर सकता है। वैकल्पिक रूप से, गणनाओं को कई प्रक्रियाओं में वितरित करने के लिए मल्टीप्रोसेसिंग का उपयोग किया जा सकता है।

GIL से निपटने के लिए सर्वोत्तम अभ्यास

GIL से निपटने के लिए यहां कुछ सर्वोत्तम अभ्यास दिए गए हैं:

• सीपीयू-बाउंड और I/O-बाउंड कार्यों की पहचान करें: यह निर्धारित करें कि आपका एप्लिकेशन मुख्य रूप से सीपीयू-बाउंड है या I/O-बाउंड है ताकि उचित समवर्ती रणनीति चुन सकें।
• सीपीयू-बाउंड कार्यों के लिए मल्टीप्रोसेसिंग का उपयोग करें: सीपीयू-बाउंड कार्यों से निपटने के दौरान, GIL को बायपास करने और सच्ची समांतरता प्राप्त करने के लिए `multiprocessing` मॉड्यूल का उपयोग करें।
• I/O-बाउंड कार्यों के लिए एसिंक्रोनस प्रोग्रामिंग का उपयोग करें: I/O-बाउंड कार्यों के लिए, कई समवर्ती संचालनों को कुशलतापूर्वक संभालने के लिए `asyncio` लाइब्रेरी का लाभ उठाएं।
• सीपीयू-गहन कार्यों को C एक्सटेंशन पर ऑफ़लोड करें: यदि प्रदर्शन महत्वपूर्ण है, तो सीपीयू-गहन कार्यों को C में लागू करने और गणना के दौरान GIL को जारी करने पर विचार करें।
• वैकल्पिक पाइथन कार्यान्वयन पर विचार करें: यदि GIL एक बड़ी बाधा है और संगतता कोई चिंता का विषय नहीं है, तो Jython या IronPython जैसे वैकल्पिक पाइथन कार्यान्वयनों का अन्वेषण करें।
• अपने कोड को प्रोफाइल करें: प्रदर्शन बाधाओं की पहचान करने और यह निर्धारित करने के लिए प्रोफाइलिंग टूल का उपयोग करें कि क्या GIL वास्तव में एक सीमित कारक है।
• सिंगल-थ्रेडेड प्रदर्शन को अनुकूलित करें: समवर्तीता पर ध्यान केंद्रित करने से पहले, सुनिश्चित करें कि आपका कोड सिंगल-थ्रेडेड प्रदर्शन के लिए अनुकूलित है।

GIL का भविष्य

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

हालांकि, पाइथन समुदाय संभावित समाधानों की खोज करना जारी रखता है, जैसे:

• सबइंटरप्रेटर्स: एक ही प्रक्रिया के भीतर समांतरता प्राप्त करने के लिए सबइंटरप्रेटर्स के उपयोग की खोज करना।
• फाइन-ग्रेन्ड लॉकिंग: GIL के दायरे को कम करने के लिए अधिक फाइन-ग्रेन्ड लॉकिंग तंत्र को लागू करना।
• बेहतर मेमोरी मैनेजमेंट: वैकल्पिक मेमोरी प्रबंधन योजनाओं का विकास करना जिन्हें GIL की आवश्यकता नहीं होती है।

हालांकि GIL का भविष्य अनिश्चित बना हुआ है, यह संभावना है कि चल रहे अनुसंधान और विकास से पाइथन और अन्य GIL-प्रभावित भाषाओं में समवर्तीता और समांतरता में सुधार होगा।

निष्कर्ष

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

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