Erlang 21

erl_driver




erlang

erl_driver

C लाइब्रेरी

erl_driver

लाइब्रेरी सारांश

API एक Erlang ड्राइवर के लिए कार्य करता है।

विवरण

एरलैंग चालक एक पुस्तकालय है जिसमें देशी ड्राइवर कॉलबैक फ़ंक्शन का एक सेट होता है जो कुछ घटनाओं के होने पर एर्लैंग वर्चुअल मशीन कॉल करता है। ड्राइवर के कई उदाहरण हो सकते हैं, प्रत्येक उदाहरण एक Erlang पोर्ट के साथ जुड़ा हुआ है।

चेतावनी

चरम देखभाल के साथ इस कार्यक्षमता का उपयोग करें।

एक चालक कॉलबैक को वीएम के मूल कोड के प्रत्यक्ष विस्तार के रूप में निष्पादित किया जाता है। निष्पादन सुरक्षित वातावरण में नहीं किया जाता है। पूर्व-खाली शेड्यूलिंग या मेमोरी प्रोटेक्शन जैसे Erlang कोड को निष्पादित करते समय VM वही सेवाएं प्रदान नहीं कर सकता है जो प्रदान करता है। यदि ड्राइवर कॉलबैक फ़ंक्शन अच्छा व्यवहार नहीं करता है, तो पूरा वीएम दुर्व्यवहार करेगा।

  • एक ड्राइवर कॉलबैक जो क्रैश पूरे वीएम को क्रैश कर देगा।

  • गलत तरीके से लागू किया गया ड्राइवर कॉलबैक, वीएम आंतरिक स्थिति असंगतता का कारण बन सकता है, जो चालक कॉलबैक के बाद कॉल के बाद किसी भी समय वीएम की दुर्घटना, या वीएम के विविध दुर्व्यवहार का कारण बन सकता है।

  • वीएम की जवाबदेही कम करने से पहले एक ड्राइवर कॉलबैक lengthy work करता है और विविध अजीब व्यवहार का कारण बन सकता है। इस तरह के अजीब व्यवहार शामिल हैं, लेकिन सीमित नहीं हैं, चरम मेमोरी उपयोग और शेड्यूलर्स के बीच खराब लोड संतुलन। अजीब व्यवहार जो लंबे समय तक काम करने के कारण हो सकता है, वह एरलांग / ओटीपी रिलीज के बीच भी भिन्न हो सकता है।

ईआरटीएस 5.5.3 से ड्राइवर इंटरफ़ेस बढ़ाया गया है ( extended marker देखें)। विस्तारित इंटरफ़ेस version management , ड्राइवर driver_flags पर रनटाइम सिस्टम के लिए क्षमता झंडे ( driver_flags देखें), और कुछ नए ड्राइवर एपीआई कार्यों को पेश करने की संभावना का परिचय देता है।

ध्यान दें

ईआरटीएस से 5.9 पुराने ड्राइवरों को फिर से तैयार किया जाना चाहिए और विस्तारित इंटरफ़ेस का उपयोग करना चाहिए। उन्हें 64-bit capable driver interface भी समायोजित किया जाना चाहिए।

ड्राइवर erl_driver.h में घोषित API फ़ंक्शन का उपयोग करके, एमुलेटर पर कॉल करता है। वे ड्राइवर से डेटा आउटपुट के लिए उपयोग किए जाते हैं, टाइमर आदि का उपयोग करते हैं।

प्रत्येक ड्राइवर का उदाहरण एक पोर्ट के साथ जुड़ा हुआ है। प्रत्येक पोर्ट में एक पोर्ट स्वामी प्रक्रिया होती है। पोर्ट के साथ संचार आमतौर पर पोर्ट मालिक प्रक्रिया के माध्यम से किया जाता है। अधिकांश फ़ंक्शन एक तर्क के रूप में port हैंडल लेते हैं। यह ड्राइवर के उदाहरण की पहचान करता है। ध्यान दें कि इस पोर्ट हैंडल को चालक द्वारा संग्रहित किया जाना चाहिए, यह तब नहीं दिया जाता है जब चालक को एमुलेटर से बुलाया जाता है ( driver_entry देखें)।

कुछ ErlDrvBinary , ErlDrvBinary , ड्राइवर बाइनरी का एक पैरामीटर लेते हैं। यह कॉलर द्वारा आवंटित और मुक्त किया जाना है। बाइनरी का उपयोग करना सीधे डेटा की एक अतिरिक्त प्रतिलिपि से बचा जाता है।

कई आउटपुट फ़ंक्शंस में "हेडर बफर" होता है, जिसमें hbuf और hlen पैरामीटर होते हैं। इस बफर को बाइनरी (या सूची, पोर्ट मोड के आधार पर) से पहले एक सूची के रूप में भेजा जाता है। पोर्ट से प्राप्त संदेशों पर मिलान करते समय यह सुविधाजनक है। (हालांकि नवीनतम Erlang संस्करणों में बाइनरी सिंटैक्स है, जो आपको बाइनरी की शुरुआत में मेल करने में सक्षम बनाता है)।

SMP समर्थन के साथ रनटाइम सिस्टम में, ड्राइवर को ड्राइवर स्तर या पोर्ट स्तर (ड्राइवर आवृत्ति स्तर) पर लॉक किया जाता है। डिफ़ॉल्ट रूप से ड्राइवर स्तर लॉकिंग का उपयोग किया जाएगा, अर्थात, एक समय में केवल एक एम्यूलेटर थ्रेड ड्राइवर में कोड निष्पादित करेगा। यदि पोर्ट स्तर लॉकिंग का उपयोग किया जाता है, तो एक ही समय में कई एम्यूलेटर थ्रेड ड्राइवर में कोड निष्पादित कर सकते हैं। हालांकि, एक बार में केवल एक धागा उसी पोर्ट के लिए ड्राइवर कॉलबैक कॉल करेगा, हालांकि। पोर्ट स्तर लॉकिंग को सक्षम करने के लिए, driver_flags द्वारा उपयोग किए गए driver_entry में ERL_DRV_FLAG_USE_PORT_LOCKING driver_flags सेट करें। जब पोर्ट स्तर लॉकिंग का उपयोग किया जाता है, तो ड्राइवर लेखक पोर्ट (ड्राइवर इंस्टेंस) द्वारा साझा किए गए डेटा तक सभी एक्सेस को सिंक्रनाइज़ करने के लिए जिम्मेदार होता है।

ड्राइवर स्तर लॉकिंग का उपयोग किया जाता है, तो SMP समर्थन के साथ रनटाइम सिस्टम से पहले लिखे गए अधिकांश ड्राइवर SMP समर्थन के साथ रनटाइम सिस्टम में चल सकते हैं।

ध्यान दें

यह माना जाता है कि ड्राइवर अन्य ड्राइवरों तक नहीं पहुंचते हैं। यदि ड्राइवर एक-दूसरे तक पहुंचते हैं, तो उन्हें थ्रेड-सुरक्षित सिंक्रनाइज़ेशन के लिए अपना तंत्र प्रदान करना होगा। इस तरह के "अंतर-चालक संचार" दृढ़ता से हतोत्साहित किया जाता है।

इससे पहले, SMP सपोर्ट के बिना रनटाइम सिस्टम में, विशिष्ट ड्राइवर कॉलबैक को हमेशा एक ही थ्रेड से बुलाया जाता था। SMP समर्थन के साथ रनटाइम सिस्टम में ऐसा नहीं है। लॉकिंग योजना का उपयोग करने के बावजूद, ड्राइवर कॉलबैक के लिए कॉल विभिन्न थ्रेड्स से किए जा सकते हैं। उदाहरण के लिए, ठीक उसी पोर्ट के लिए एक ही कॉलबैक के लिए दो लगातार कॉल दो अलग-अलग थ्रेड से किए जा सकते हैं। यह ज्यादातर ड्राइवरों के लिए समस्या नहीं है, लेकिन यह हो सकता है। ड्राइवर जो सभी कॉलबैक पर निर्भर करते हैं जिन्हें एक ही थ्रेड में कहा जाता है, उन्हें SMP समर्थन के साथ रनटाइम सिस्टम में उपयोग करने से पहले फिर से लिखना होगा

ध्यान दें

लॉकिंग योजना का उपयोग करने के बावजूद, ड्राइवर कॉलबैक के लिए कॉल विभिन्न थ्रेड्स से किए जा सकते हैं।

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

चेतावनी

थ्रेड-सेफ के रूप में स्पष्ट रूप से प्रलेखित कार्य थ्रेड सुरक्षित नहीं हैं। यह भी ध्यान दें कि SMP समर्थन के साथ रनटाइम सिस्टम में उपयोग किए जाने पर कुछ फ़ंक्शन केवल थ्रेड-सुरक्षित होते हैं।

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

केवल स्पष्ट रूप से मनमाने धागे से धागे के रूप में प्रलेखित कार्यों का उपयोग करें।

जैसा कि इस खंड की शुरुआत में warning पाठ में उल्लेख किया गया है, यह महत्वपूर्ण महत्व है कि एक ड्राइवर कॉलबैक अपेक्षाकृत तेजी से लौटता है। एक सटीक अधिकतम समय देना मुश्किल है कि एक ड्राइवर कॉलबैक को काम करने की अनुमति है, लेकिन आमतौर पर एक अच्छा व्यवहार करने वाला ड्राइवर कॉलबैक 1 मिलीसेकंड के भीतर वापस आना है। विभिन्न दृष्टिकोणों का उपयोग करके इसे प्राप्त किया जा सकता है। यदि आपके पास ड्राइवर कॉलबैक में निष्पादित करने के लिए कोड पर पूर्ण नियंत्रण है, तो सबसे अच्छा तरीका यह है कि काम को कई कार्यों में विभाजित किया जाए, और शून्य-समय का उपयोग करके time-out callback कई कॉल ट्रिगर करें। फंक्शन erl_drv_consume_timeslice ऐसे टाइम-आउट कॉलबैक कॉल को ट्रिगर करने के लिए निर्धारित करने के लिए उपयोगी हो सकता है। हालांकि, कभी-कभी इसे इस तरह से लागू नहीं किया जा सकता है, उदाहरण के लिए तीसरे पक्ष के पुस्तकालयों को कॉल करते समय। इस मामले में, आप आम तौर पर काम को दूसरे धागे में भेजना चाहते हैं। थ्रेड प्राइमेटिव के बारे में जानकारी नीचे दी गई है।

कार्यक्षमता

सभी कार्य जो ड्राइवर को एर्लांग के साथ करने की आवश्यकता होती है, ड्राइवर एपीआई कार्यों के माध्यम से किए जाते हैं। निम्नलिखित कार्यक्षमता के लिए कार्य मौजूद हैं:

टाइमर कार्य करता है

उस टाइमर को नियंत्रित करें जिसका ड्राइवर उपयोग कर सकता है। टाइमर में एमुलेटर कॉल निर्दिष्ट समय के बाद timeout प्रविष्टि फ़ंक्शन है। प्रत्येक ड्राइवर उदाहरण के लिए केवल एक टाइमर उपलब्ध है।

कतार से निपटने

हर ड्राइवर उदाहरण में एक संबद्ध कतार होती है। यह कतार एक SysIOVec , जो एक बफर के रूप में काम करता है। यह ज्यादातर ड्राइवर के लिए डेटा को बफर करने के लिए उपयोग किया जाता है जिसे डिवाइस पर लिखा जाना है, यह एक बाइट स्ट्रीम है। यदि पोर्ट स्वामी प्रक्रिया ड्राइवर को बंद कर देती है, और कतार खाली नहीं है, तो ड्राइवर बंद नहीं होता है। यह ड्राइवर को बंद करने से पहले अपने बफ़र्स को फ्लश करने में सक्षम बनाता है।

यदि पोर्ट डेटा लॉक का उपयोग किया जाता है, तो कतार को किसी भी थ्रेड से हेरफेर किया जा सकता है। अधिक जानकारी के लिए, ErlDrvPDL देखें।

आउटपुट फ़ंक्शन

इन कार्यों के साथ, चालक एमुलेटर पर डेटा वापस भेजता है। डेटा पोर्ट स्वामी प्रक्रिया द्वारा संदेशों के रूप में प्राप्त होता है, erlang:open_port/2 देखें erlang:open_port/2 । वेक्टर फ़ंक्शन और ड्राइवर बाइनरी लेने वाले फ़ंक्शन तेज़ होते हैं, क्योंकि वे डेटा बफर कॉपी करने से बचते हैं। बाइनरी टर्म प्रारूप के माध्यम से जाने के बिना, ड्राइवर से शब्द भेजने का एक तेज़ तरीका भी है।

असफलता

ड्राइवर एरलांग तक त्रुटियों से बाहर निकल सकता है और संकेत दे सकता है। यह केवल गंभीर त्रुटियों के लिए है, जब ड्राइवर संभवतः खुला नहीं रख सकता है।

अतुल्यकालिक कॉल

Erlang / OTP R7B और बाद के संस्करणों में Erlang द्वारा प्रदान किए गए एक थ्रेड पूल का उपयोग करते हुए, अतुल्यकालिक फ़ंक्शन कॉल का प्रावधान है। एक चयन कॉल भी है, जिसका उपयोग एसिंक्रोनस ड्राइवरों के लिए किया जा सकता है।

बहु सूत्रण

मल्टी-थ्रेडिंग के लिए एपीआई की तरह एक पोसिक्स धागा प्रदान किया जाता है। Erlang ड्राइवर थ्रेड API केवल POSIX थ्रेड API द्वारा प्रदान की गई कार्यक्षमता का सबसेट प्रदान करता है। उप-उपलब्ध कराई गई बहु-थ्रेडेड प्रोग्रामिंग के लिए आवश्यक बुनियादी कार्यक्षमता कम या ज्यादा है:

Erlang ड्राइवर थ्रेड API का उपयोग UN-ices पर POSIX थ्रेड API और Windows पर Windows मूल थ्रेड API के साथ संयोजन में किया जा सकता है। Erlang ड्राइवर थ्रेड API में पोर्टेबल होने का लाभ है, लेकिन ऐसी परिस्थितियाँ हो सकती हैं जहाँ आप POSIX थ्रेड API या Windows देशी थ्रेड API से कार्यक्षमता का उपयोग करना चाहते हैं।

Erlang ड्राइवर थ्रेड API केवल त्रुटि कोड देता है जब त्रुटि स्थिति से उबरना उचित होता है। यदि एक त्रुटि स्थिति से उबरना उचित नहीं है, तो पूरे रनटाइम सिस्टम को समाप्त कर दिया जाता है। उदाहरण के लिए, यदि एक म्यूटेक्स ऑपरेशन विफल हो जाता है, तो एक त्रुटि कोड वापस आ जाता है, लेकिन यदि म्यूटेक्स पर लॉक ऑपरेशन विफल हो जाता है, तो पूरे रनटाइम सिस्टम को समाप्त कर दिया जाता है।

ध्यान दें कि Erlang ड्राइवर थ्रेड API में "टाइम-आउट के साथ कोई कंडीशन वैरिएबल वेट" नहीं है। यह pthread_cond_timedwait साथ समस्याओं के कारण है। जब सिस्टम घड़ी को अचानक बदल दिया जाता है, तो हमेशा यह गारंटी नहीं दी जाती है कि आप उम्मीद के मुताबिक कॉल से उठेंगे। एर्लांग रनटाइम सिस्टम को सिस्टम घड़ी के अचानक परिवर्तनों से निपटने में सक्षम होना चाहिए। इसलिए, हमने एर्लांग ड्राइवर थ्रेड एपीआई से इसे छोड़ दिया है। Erlang ड्राइवर के मामले में, टाइम-आउट को Erlang ड्राइवर API की टाइमर कार्यक्षमता के साथ नियंत्रित किया जा सकता है।

Erlang ड्राइवर थ्रेड API को कार्य करने के लिए, रनटाइम सिस्टम में थ्रेड का समर्थन सक्षम होना चाहिए। एक Erlang ड्राइवर जाँच सकता है कि क्या थ्रेड सपोर्ट driver_system_info उपयोग द्वारा सक्षम है। ध्यान दें कि Erlang ड्राइवर API में कुछ फ़ंक्शन केवल थ्रेड-सुरक्षित होते हैं, जब रनटाइम सिस्टम में SMP सपोर्ट होता है, यह जानकारी भी driver_system_info माध्यम से प्राप्त की जा सकती है। यह भी ध्यान दें कि एर्लांग चालक एपीआई में कई फ़ंक्शन थ्रेड-सुरक्षित नहीं हैं, चाहे एसएमपी समर्थन सक्षम हो या न हो। यदि कोई फ़ंक्शन थ्रेड-सुरक्षित के रूप में प्रलेखित नहीं है, तो यह थ्रेड-सुरक्षित नहीं है।

ध्यान दें

एमुलेटर थ्रेड में निष्पादित करते समय, यह बहुत महत्वपूर्ण है कि आप अपने नियंत्रण से बाहर थ्रेड को देने से पहले आपके द्वारा लॉक किए गए सभी लॉक को अनलॉक करें; अन्यथा आप पूरे एमुलेटर का गतिरोध करने की बहुत संभावना रखते हैं।

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

भविष्य में, डिबग कार्यक्षमता संभवतः Erlang ड्राइवर थ्रेड API के साथ एकीकृत होगी। संस्थाएँ बनाने वाले सभी फ़ंक्शंस एक name तर्क लेते हैं। वर्तमान में name तर्क अप्रयुक्त है, लेकिन डीबग कार्यक्षमता लागू होने पर इसका उपयोग किया जाएगा। यदि आप अच्छी तरह से बनाई गई सभी संस्थाओं को नाम देते हैं, तो डीबग कार्यक्षमता आपको बेहतर त्रुटि रिपोर्ट देने में सक्षम होगी।

ड्राइवर जोड़ना / निकालना

एक ड्राइवर ड्राइवरों को जोड़ सकता है और बाद में हटा सकता है।

निगरानी की प्रक्रिया

एक ड्राइवर एक ऐसी प्रक्रिया की निगरानी कर सकता है जो एक बंदरगाह का मालिक नहीं है।

संस्करण प्रबंधन

संस्करण प्रबंधन उन ड्राइवरों के लिए सक्षम है, driver_entry अपने driver_entry के extended_marker फ़ील्ड को driver_entry पर ERL_DRV_EXTENDED_MARKER erl_driver.h परिभाषित करता है:

  • ERL_DRV_EXTENDED_MARKER

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

  • ERL_DRV_EXTENDED_MINOR_VERSION , जो नई सुविधाएँ जोड़े जाने पर बढ़ाई जाती है। रनटाइम सिस्टम ड्राइवर के मामूली संस्करण का उपयोग करता है यह निर्धारित करने के लिए कि सुविधाओं का क्या उपयोग करना है।

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

एमुलेटर 64-बिट सक्षम ड्राइवरों के लिए अनुमति देने के लिए विस्तारित ड्राइवर इंटरफ़ेस का उपयोग नहीं करने वाले ड्राइवर को लोड करने से इनकार करता है, क्योंकि कॉलबैक output , control और call लिए असंगत प्रकार के परिवर्तन Erlang / OTP R15B में पेश किए गए थे। पुराने प्रकारों के साथ लिखा गया ड्राइवर चेतावनी के साथ संकलित करेगा और जब एमुलेटर पर रिटर्न गारबेज आकार कहा जाएगा, जिससे यह बेतरतीब मेमोरी को पढ़ेगा और भारी गलत परिणाम पैदा करेगा।

इसलिए यह केवल पूर्ववर्ती R15B प्रकारों के लिए संस्करण प्रबंधन के साथ लिखे गए रेम्पाइल ड्राइवरों के लिए पर्याप्त नहीं है; ड्राइवर को अन्य रीराइट्स का सुझाव देते हुए प्रकारों को बदलना होगा, विशेष रूप से आकार चर के बारे में। जब recompiling सभी चेतावनियों की जाँच करें।

इसके अलावा, API ड्राइवर फ़ंक्शंस में driver_output* और driver_vec_to_buf , driver_alloc/realloc* , और driver_* कतार फ़ंक्शंस को बड़ी लंबाई के तर्क और वापसी मान के लिए बदल दिया गया था। यह एक कम समस्या है, क्योंकि कोड जो छोटे प्रकार से गुजरता है, उन्हें कॉल में ऑटो-परिवर्तित हो जाता है, और जब तक ड्राइवर एक ऐसे आकार को नहीं संभालता है जो एक int ओवरफ्लो करता है, सभी पहले की तरह काम करेंगे।

समय का मापन

ड्राइवरों में समय मापन के लिए समर्थन:

64-बिट ड्राइवर इंटरफ़ेस के लिए फिर से लिखना

ERTS 5.9 ने दो नए पूर्णांक प्रकार, ErlDrvSizeT और ErlDrvSSizeT , जो यदि आवश्यक हो तो 64-बिट आकार रख सकते हैं।

एक ड्राइवर और केवल recompile को अपडेट नहीं करने के लिए, यह संभवतया तब काम करता है जब 32-बिट मशीन के लिए निर्माण सुरक्षा की झूठी भावना पैदा करता है। उम्मीद है कि कई महत्वपूर्ण चेतावनी उत्पन्न करेगा। लेकिन जब एक ही ड्राइवर को 64-बिट मशीन के लिए बाद में पुनः स्थापित किया जाता है, तो चेतावनी और लगभग निश्चित रूप से क्रैश हो जाएगा। इसलिए ड्राइवर को अपडेट करना और चेतावनी को ठीक नहीं करना एक बुरा विचार है।

जब gcc साथ recompiling करते हैं, तो बेहतर चेतावनी प्राप्त करने के लिए ध्वज का उपयोग करें -Wstrict-prototypes । यदि आप किसी अन्य संकलक का उपयोग करते हैं तो समान ध्वज खोजने का प्रयास करें।

निम्नलिखित एक पूर्व ERTS 5.9 ड्राइवर के पुनर्लेखन के लिए एक चेकलिस्ट है, जो सबसे महत्वपूर्ण है:

ड्राइवर कॉलबैक के लिए वापसी प्रकार

ErlDrvSSizeT बजाय रिटर्न टाइप ErlDrvSSizeT का उपयोग करने के लिए ड्राइवर कॉलबैक control को फिर से लिखें।

ErlDrvSSizeT बजाय रिटर्न टाइप ErlDrvSSizeT का उपयोग करने के लिए ड्राइवर कॉलबैक को फिर से call

ध्यान दें

ये परिवर्तन आवश्यक हैं कि एमुलेटर को खराब न करें या खराब होने का कारण बने। उनके बिना एक चालक एमुलेटर में उच्च 32 बिट्स में कचरा वापस कर सकता है, जिससे यह यादृच्छिक बाइट्स से एक बड़ा परिणाम बनता है, या तो मेमोरी आवंटन पर क्रैश होता है या ड्राइवर कॉल से यादृच्छिक परिणाम के साथ सफल होता है।

ड्राइवर कॉलबैक के लिए तर्क

ड्राइवर कॉलबैक output अब ErlDrvSizeT को पहले वाले int बजाय 3 तर्क के रूप में ErlDrvSizeT करता है।

ड्राइवर कॉलबैक control अब ErlDrvSizeT को पहले वाले int बजाय 4 वें और 6 वें तर्कों के रूप में मिलता है।

ड्राइवर कॉलबैक call अब ErlDrvSizeT को पहले वाले int बजाय 4 वें और 6 वें तर्कों के रूप में मिलती है।

साने कंपाइलर के कॉलिंग कन्वेंशन शायद इन बदलावों को केवल ड्राइवर के लिए जरूरी है कि वह डेटा चंक्स को हैंडल करे जिसके लिए 64-बिट साइज फील्ड्स की जरूरत होती है (ज्यादातर 2 जीबी से ज्यादा बड़े होते हैं, जो कि 32 बिट्स की इंट्री पकड़ सकते हैं)। लेकिन गैर-कॉलिंग सम्मेलनों के बारे में सोचना संभव है जो ड्राइवर कॉलबैक को खराबी पैदा करने वाले तर्कों को मिलाते हैं।

ध्यान दें

तर्क प्रकार परिवर्तन हस्ताक्षरित से अहस्ताक्षरित है। उदाहरण के लिए, लूप समाप्ति शर्तों या त्रुटि स्थितियों के लिए यह समस्या पैदा कर सकता है, यदि आप केवल सभी प्रकार के स्थान बदलते हैं।

ErlIOVec में बड़ा size फ़ील्ड

ErlIOVec में size फ़ील्ड को int से ErlDrvSizeT में बदल दिया गया है। उस फ़ील्ड का उपयोग करने वाले सभी कोड की जाँच करें।

स्वचालित प्रकार-कास्टिंग संभवतः इन परिवर्तनों को केवल एक ड्राइवर के लिए आवश्यक बनाता है जो आकार> 32 बिट्स का सामना करता है।

ध्यान दें

size फ़ील्ड को हस्ताक्षरित से बदलकर अहस्ताक्षरित कर दिया गया। उदाहरण के लिए, लूप समाप्ति शर्तों या त्रुटि स्थितियों के लिए यह समस्या पैदा कर सकता है, यदि आप केवल सभी प्रकार के स्थान बदलते हैं।

ड्राइवर API में तर्क और वापसी मान

कई ड्राइवर API फ़ंक्शंस ने ज्यादातर int से तर्क प्रकार और / या रिटर्न मान ErlDrvSizeT बदल दिए हैं। स्वचालित प्रकार-कास्टिंग संभवतः इन परिवर्तनों को केवल एक ड्राइवर के लिए आवश्यक बनाता है जो आकार> 32 बिट्स का सामना करता है।

driver_output
तीसरा तर्क
driver_output2
3 और 5 वें तर्क
driver_output_binary
तीसरा, 5 वां और 6 वां तर्क
driver_outputv
3 और 5 वें तर्क
driver_vec_to_buf
3 तर्क और वापसी मूल्य
driver_alloc
1 तर्क
driver_realloc
दूसरा तर्क
driver_alloc_binary
1 तर्क
driver_realloc_binary
दूसरा तर्क
driver_enq
तीसरा तर्क
driver_pushq
तीसरा तर्क
driver_deq
2 तर्क और वापसी मूल्य
driver_sizeq
प्रतिलाभ की मात्रा
driver_enq_bin
तीसरी और चौथी दलील
driver_pushq_bin
तीसरी और चौथी दलील
driver_enqv
तीसरा तर्क
driver_pushqv
तीसरा तर्क
driver_peekqv
प्रतिलाभ की मात्रा
ध्यान दें

यह हस्ताक्षरित से अहस्ताक्षरित में परिवर्तन है। यह उदाहरण के लिए, लूप समाप्ति की स्थिति और त्रुटि स्थितियों के लिए समस्या पैदा कर सकता है, यदि आप केवल सभी प्रकार के स्थान बदलते हैं।

जानकारी का प्रकार

ErlDrvSizeT

एक अहस्ताक्षरित पूर्णांक प्रकार size_t रूप में उपयोग किया जाता है।

ErlDrvSSizeT

एक हस्ताक्षरित पूर्णांक प्रकार, ErlDrvSizeT का आकार।

ErlDrvSysInfo
typedef struct ErlDrvSysInfo {
   int driver_major_version;
   int driver_minor_version;
   char *erts_version;
   char *otp_release;
   int thread_support;
   int smp_support;
   int async_threads;
   int scheduler_threads;
   int nif_major_version;
   int nif_minor_version;
   int dirty_scheduler_support;
} ErlDrvSysInfo;

ErlDrvSysInfo संरचना का उपयोग Erlang रनटाइम सिस्टम के बारे में जानकारी के भंडारण के लिए किया जाता है। जब एक ErlDrvSysInfo संरचना के संदर्भ में ErlDrvSysInfo सिस्टम जानकारी लिखता है। संरचना के क्षेत्र निम्नानुसार हैं:

driver_major_version

रनटाइम सिस्टम संकलित होने पर ERL_DRV_EXTENDED_MAJOR_VERSION का मान। यह मान ड्राइवर के संकलन के समय उपयोग किए गए ERL_DRV_EXTENDED_MAJOR_VERSION के मान के ERL_DRV_EXTENDED_MAJOR_VERSION है; अन्यथा रनटाइम सिस्टम ने ड्राइवर को लोड करने से मना कर दिया होता।

driver_minor_version

रनटाइम सिस्टम संकलित होने पर ERL_DRV_EXTENDED_MINOR_VERSION का मान। ड्राइवर का संकलन करते समय उपयोग किए जाने वाले ERL_DRV_EXTENDED_MINOR_VERSION के मान से यह मान भिन्न हो सकता है।

erts_version

रनटाइम सिस्टम के संस्करण की संख्या वाला एक स्ट्रिंग ( erlang:system_info(version) द्वारा लौटाया गया erlang:system_info(version) )।

otp_release

OTP रिलीज़ संख्या ( erlang:system_info(otp_release) द्वारा लौटाए गए erlang:system_info(otp_release) ) के साथ एक स्ट्रिंग।

thread_support

एक मान != 0 यदि रनटाइम सिस्टम में थ्रेड समर्थन है; अन्यथा 0

smp_support

एक मान != 0 यदि रनटाइम सिस्टम में एसएमपी समर्थन है; अन्यथा 0

async_threads

Async थ्रेड पूल में async थ्रेड्स की संख्या जिसका उपयोग driver_async द्वारा किया जाता है ( erlang:system_info(thread_pool_size) द्वारा लौटाया गया erlang:system_info(thread_pool_size) )।

scheduler_threads

रनटाइम सिस्टम द्वारा उपयोग किए जाने वाले शेड्यूलर थ्रेड्स की संख्या ( erlang:system_info(schedulers) द्वारा लौटाए गए के समान erlang:system_info(schedulers) )।

nif_major_version

रनटाइम सिस्टम संकलित होने पर ERL_NIF_MAJOR_VERSION का मान।

nif_minor_version

रनटाइम सिस्टम संकलित होने पर ERL_NIF_MINOR_VERSION का मान।

dirty_scheduler_support

एक मान != 0 यदि रनटाइम सिस्टम में गंदे शेड्यूलर थ्रेड्स के लिए समर्थन है; अन्यथा 0

ErlDrvBinary
typedef struct ErlDrvBinary {
   ErlDrvSint orig_size;
   char orig_bytes[];
} ErlDrvBinary;

ErlDrvBinary संरचना एक बाइनरी है, जैसा कि एमुलेटर और ड्राइवर के बीच भेजा जाता है। सभी बायनेरिज़ को गिना गया संदर्भ है; जब driver_binary_free कहा जाता है, तो संदर्भ संख्या को घटाया जाता है, जब यह शून्य तक पहुंचता है, तो बाइनरी को driver_binary_free दिया जाता है। orig_size द्विआधारी आकार है और orig_bytes बफर है। ErlDrvBinary का कोई निश्चित आकार नहीं है, इसका आकार orig_size + 2 * sizeof(int)

ध्यान दें

refc फील्ड को हटा दिया गया है। एक ErlDrvBinary की संदर्भ गणना अब कहीं और संग्रहीत की जाती है। एक ErlDrvBinary की संदर्भ संख्या को driver_binary_get_refc , driver_binary_inc_refc , और driver_binary_dec_refc माध्यम से एक्सेस किया जा सकता है।

कुछ ड्राइवर कॉल, जैसे कि driver_enq_binary , ड्राइवर रेफरेंस काउंट बढ़ाते हैं, और अन्य, जैसे driver_deq इसे driver_deq हैं।

सामान्य बफ़र के बजाय ड्राइवर बाइनरी का उपयोग करना अक्सर तेज़ होता है, क्योंकि एमुलेटर को डेटा को कॉपी करने की आवश्यकता नहीं होती है, केवल पॉइंटर का उपयोग किया जाता है।

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

ड्राइवर बायनेरी का उपयोग driver_output2 और driver_outputv कॉल में, और कतार में किया जाता है। इसके अलावा ड्राइवर कॉलबैक outputv ड्राइवर बायनेरिज़ का उपयोग करता है।

यदि ड्राइवर किसी कारण से ड्राइवर को बाइनरी के आसपास रखना चाहता है, उदाहरण के लिए एक स्थिर चर में, संदर्भ गणना को driver_free_binary जाना है, और बाइनरी को बाद में stop कॉलबैक में driver_free_binary साथ मुक्त किया जा सकता है।

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

ERTS 5.5 (Erlang / OTP R11B) के बाद से, orig_bytes को युगल के एक सरणी (आमतौर पर 8-बाइट गठबंधन) के भंडारण के लिए ठीक से संरेखित करने की गारंटी है।

ErlDrvData

ड्राइवर-विशिष्ट डेटा के लिए एक हैंडल, ड्राइवर कॉलबैक को पास किया गया। यह एक पॉइंटर है, और ड्राइवर में एक विशिष्ट पॉइंटर को सबसे अधिक बार टाइप किया जाता है।

SysIOVec

एक प्रणाली I / O वेक्टर, जैसा कि writev पर Unix और WSASend पर WSASend द्वारा उपयोग किया जाता है। इसका उपयोग ErlIOVec में किया जाता है।

ErlIOVec
typedef struct ErlIOVec {
  int vsize;
  ErlDrvSizeT size;
  SysIOVec* iov;
  ErlDrvBinary** binv;
} ErlIOVec;

एमुलेटर और ड्राइवरों द्वारा उपयोग किया जाने वाला I / O वेक्टर बायनेरिज़ की एक सूची है, जिसमें बायनेरिज़ के बफ़र्स को इंगित करते हुए SysIOVec । इसका उपयोग driver_outputv और outputv ड्राइवर कॉलबैक में किया जाता है। इसके अलावा, ड्राइवर कतार एक ErlIOVec

ErlDrvMonitor

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

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

ErlDrvNowData

ErlDrvNowData संरचना समय में कुछ मनमाना बिंदु से मापा तीन मूल्यों से मिलकर एक समय टिकट रखता है। तीन संरचना सदस्य हैं:

megasecs
समय में मनमाने बिंदु के बाद से पूरे मेगासेकंड की संख्या समाप्त हो गई
secs
समय में मनमानी बिंदु के बाद पूरे सेकंड की संख्या समाप्त हो गई
microsecs
समय में मनमाने बिंदु के बाद से पूरे माइक्रोसेकंड की संख्या समाप्त हो गई
ErlDrvPDL

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

आम तौर पर ड्राइवर के उदाहरण में पोर्ट डेटा लॉक नहीं होता है। यदि ड्राइवर आवृत्ति पोर्ट डेटा लॉक का उपयोग करना चाहता है, तो उसे driver_pdl_create कॉल करके पोर्ट डेटा लॉक बनाना होगा।

ध्यान दें

एक बार पोर्ट डेटा लॉक बन जाने के बाद, पोर्ट डेटा लॉक से जुड़े डेटा तक हर एक्सेस होना चाहिए, जबकि पोर्ट डेटा लॉक लॉक है। पोर्ट डेटा लॉक को क्रमशः driver_pdl_lock , और driver_pdl_unlock द्वारा लॉक और अनलॉक किया जाता है।

एक पोर्ट डेटा लॉक को रेफरेंस काउंट किया जाता है, और जब रेफरेंस काउंट शून्य तक पहुंच जाता है, तो यह नष्ट हो जाता है। कम से कम एमुलेटर कम से कम एक बार रेफरेंस काउंट को बढ़ाता है जब लॉक बनाया जाता है और लॉक टर्मेट्स से जुड़े पोर्ट को एक बार घटाता है। एमुलेटर जॉब इंक्यूबेट होने पर इसे रेफरेंस काउंट बढ़ाता है और जब एसिंक्स जॉब इंक्वायरी की जाती है तो इसे घटा देता है। इसके अलावा, ड्राइवर यह सुनिश्चित करने के लिए जिम्मेदार है कि ड्राइवर द्वारा लॉक के अंतिम उपयोग से पहले संदर्भ गणना शून्य तक नहीं पहुंचती है। रेफरेंस काउंट क्रमशः driver_pdl_dec_refc driver_pdl_get_refc , driver_pdl_inc_refc , और driver_pdl_dec_refc द्वारा पढ़ा, बढ़ा, और घटाया जा सकता है।

ErlDrvTid

धागा पहचानकर्ता।

erl_drv_thread_create , erl_drv_thread_exit , erl_drv_thread_join , erl_drv_thread_self , और erl_drv_equal_tids भी देखें।

ErlDrvThreadOpts
int suggested_stack_size;

थ्रेड विकल्प संरचना erl_drv_thread_create को पास की erl_drv_thread_create । निम्न फ़ील्ड मौजूद है:

suggested_stack_size
एक सुझाव, किलोवाट में, उपयोग करने के लिए एक बड़े ढेर पर। मान <0 का अर्थ है डिफ़ॉल्ट आकार।

erl_drv_thread_opts_create , erl_drv_thread_opts_destroy , और erl_drv_thread_create भी देखें।

ErlDrvMutex

आपसी बहिष्कार ताला। साझा डेटा तक पहुंच को सिंक्रनाइज़ करने के लिए उपयोग किया जाता है। एक समय में केवल एक धागा म्यूटेक्स को लॉक कर सकता है।

erl_drv_mutex_create , erl_drv_mutex_destroy , erl_drv_mutex_lock , erl_drv_mutex_trylock , और erl_drv_mutex_unlock भी देखें।

ErlDrvCond

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

erl_drv_cond_create , erl_drv_cond_destroy , erl_drv_cond_signal , erl_drv_cond_broadcast , और erl_drv_cond_wait भी देखें।

ErlDrvRWLock

पढ़ें / ताला लिखें। साझा किए गए डेटा को पढ़ने के लिए कई थ्रेड्स की अनुमति देने के लिए उपयोग किया जाता है जबकि केवल एक थ्रेड को एक ही डेटा लिखने की अनुमति देता है। एकाधिक थ्रेड्स एक ही समय में एक लॉक लॉक को पढ़ सकते हैं, जबकि एक थ्रेड लॉक को एक समय में पढ़ / लिख सकते हैं।

erl_drv_rwlock_create , erl_drv_rwlock_destroy , erl_drv_rwlock_rlock , erl_drv_rwlock_tryrlock erl_drv_rwlock_runlock , erl_drv_rwlock_rwlock , erl_drv_rwlock_tryrwlock & erl_drv_rwlock_rwunlock

ErlDrvTSDKey

कुंजी जिसे थ्रेड-विशिष्ट डेटा के साथ जोड़ा जा सकता है।

erl_drv_tsd_key_create , erl_drv_tsd_key_destroy , erl_drv_tsd_set , और erl_drv_tsd_get भी देखें।

ErlDrvTime

समय प्रतिनिधित्व के लिए एक हस्ताक्षरित 64-बिट पूर्णांक प्रकार।

ErlDrvTimeUnit

ड्राइवर API द्वारा समर्थित समय इकाइयों की गणना:

ERL_DRV_SEC
सेकंड
ERL_DRV_MSEC
मिलीसेकंड
ERL_DRV_USEC
माइक्रोसेकंड
ERL_DRV_NSEC
नैनोसेकंड

निर्यात

void add_driver_entry(ErlDrvEntry *de)

Erlang द्वारा ज्ञात ड्राइवरों की सूची में ड्राइवर प्रविष्टि जोड़ता है। पैरामीटर de init फ़ंक्शन को कहा जाता है।

ध्यान दें

गतिशील रूप से लोड कोड में रहने वाले ड्राइवरों को जोड़ने के लिए इस फ़ंक्शन का उपयोग करना खतरनाक है। यदि जोड़े गए ड्राइवर का ड्राइवर कोड सामान्य गतिशील रूप से लोड किए गए ड्राइवर ( erl_ddll इंटरफ़ेस के साथ लोड) के रूप में एक ही गतिशील रूप से लोड किए गए मॉड्यूल ( .so फ़ाइल) में रहता है, .so कॉल करने वाले को ड्राइवर प्रविष्टियों को जोड़ने से पहले driver_lock_driver को कॉल करना driver_lock_driver

इस फ़ंक्शन का उपयोग आमतौर पर पदावनत किया जाता है।

void *driver_alloc(ErlDrvSizeT size)

आकार में निर्दिष्ट आकार का मेमोरी ब्लॉक आवंटित करता है, और उसे वापस करता है। यह केवल मेमोरी से बाहर निकलने में विफल रहता है, जिस स्थिति में NULL को लौटाया जाता है। (यह अक्सर मॉलॉक के लिए एक आवरण है)।

आवंटित स्मृति को स्पष्ट रूप से driver_free अनुरूप कॉल के साथ मुक्त किया जाना चाहिए (जब तक कि अन्यथा कहा न जाए)।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

ErlDrvBinary *driver_alloc_binary(ErlDrvSizeT size)

कम से कम size बाइट्स के मेमोरी ब्लॉक के साथ एक ड्राइवर बाइनरी आवंटित करता है, और इसके लिए एक संकेतक लौटाता है, या विफलता (मेमोरी से बाहर) पर NULL होता है। जब ड्राइवर बाइनरी को एमुलेटर पर भेजा गया है, तो इसे बदलना नहीं चाहिए। हर आवंटित बाइनरी को driver_free_binary (जब तक कि अन्यथा कहा गया) के अनुरूप कॉल द्वारा मुक्त नहीं किया जाना है।

ध्यान दें कि एक ड्राइवर बाइनरी में एक आंतरिक संदर्भ काउंटर है। इसका मतलब है कि driver_free_binary कॉल driver_free_binary , यह वास्तव में इसका निपटान नहीं कर सकता है। यदि इसे एमुलेटर पर भेजा जाता है, तो इसे वहां संदर्भित किया जा सकता है।

ड्राइवर बाइनरी में एक फ़ील्ड, orig_bytes , जो बाइनरी में डेटा की शुरुआत को चिह्नित करता है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

long driver_async(ErlDrvPort port, unsigned int* key, void (*async_invoke)(void*), void* async_data, void (*async_free)(void*))

एक एसिंक्रोनस कॉल करता है। फ़ंक्शन async_invoke को एमुलेटर थ्रेड से अलग थ्रेड में लगाया जाता है। यह ड्रायवर को समय-उपभोग करने में सक्षम बनाता है, एमुलेटर को अवरुद्ध किए बिना संचालन को अवरुद्ध करता है।

Async थ्रेड पूल का आकार erl(1) में कमांड-लाइन तर्क +A साथ सेट किया जा सकता है। यदि कोई async थ्रेड पूल अनुपलब्ध है, तो कॉल को थ्रेड कॉलिंग driver_async में सिंक्रोनाइज़ किया driver_async । Async थ्रेड पूल में async थ्रेड्स की वर्तमान संख्या को driver_system_info माध्यम से पुनर्प्राप्त किया जा सकता है।

यदि एक थ्रेड पूल उपलब्ध है, तो एक थ्रेड का उपयोग किया जाता है। यदि तर्क key NULL , तो पूल से थ्रेड्स को राउंड-रॉबिन तरीके से उपयोग किया जाता है, driver_async लिए प्रत्येक कॉल पूल में अगले थ्रेड का उपयोग करता है। तर्क key सेट के साथ, यह व्यवहार बदल जाता है। *key दो समान मूल्यों को हमेशा एक ही धागा मिलता है।

यह सुनिश्चित करने के लिए कि ड्राइवर का उदाहरण हमेशा एक ही धागे का उपयोग करता है, निम्नलिखित कॉल का उपयोग किया जा सकता है:

unsigned int myKey = driver_async_port_key(myPort);

r = driver_async(myPort, &myKey, myData, myFunc);    

प्रत्येक ड्राइवर उदाहरण के लिए एक बार myKey को इनिशियलाइज़ करना पर्याप्त है।

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

async_data कार्यों के लिए तर्क async_invoke और async_free । यह आमतौर पर एक पाइप या घटना वाली संरचना का एक संकेतक होता है जिसका उपयोग यह इंगित करने के लिए किया जा सकता है कि एसिंक्स ऑपरेशन पूरा हुआ। डेटा को async_free में मुक्त किया async_free

जब Async ऑपरेशन किया जाता है, तो ready_async ड्राइवर एंट्री फ़ंक्शन को कहा जाता है। यदि ड्राइवर प्रविष्टि में ready_async NULL है, तो इसके बजाय async_free फ़ंक्शन को कॉल किया जाता है।

अगर driver_async कॉल विफल हो जाता है तो रिटर्न वैल्यू -1 है।

ध्यान दें

ईआरटीएस 5.5.4.3 से async-थ्रेड पूल में थ्रेड्स के लिए डिफ़ॉल्ट स्टैक आकार 16 किलोवाट है, अर्थात 32-बिट आर्किटेक्चर पर 64 किलोबाइट है। इस छोटे से डिफ़ॉल्ट आकार को चुना गया है क्योंकि एसिंक्स-थ्रेड्स की मात्रा काफी बड़ी हो सकती है। डिफ़ॉल्ट स्टैक आकार Erlang / OTP के साथ दिए गए ड्राइवरों के लिए पर्याप्त है, लेकिन संभवतः अन्य डायनेमिक रूप से लिंक किए गए ड्राइवरों के लिए पर्याप्त रूप से बड़ा नहीं है जो driver_async कार्यक्षमता का उपयोग करते हैं। Async-थ्रेड पूल में थ्रेड्स के लिए सुझाए गए स्टैक आकार को कमांड-लाइन तर्क +a erl(1) माध्यम से कॉन्फ़िगर किया जा सकता है।

unsigned int driver_async_port_key(ErlDrvPort port)

driver_async में बाद में उपयोग के लिए एक कुंजी की गणना करता है। चाबियाँ समान रूप से वितरित की जाती हैं ताकि पोर्ट आईडी और एसिंक्स थ्रेड आईडी के बीच एक उचित मानचित्रण प्राप्त हो।

ध्यान दें

Erlang / OTP R16 से पहले, पोर्ट आईडी को उचित कास्टिंग के साथ एक कुंजी के रूप में इस्तेमाल किया जा सकता है, लेकिन पोर्ट सबसिस्टम के फिर से लिखे जाने के बाद, यह अब ऐसा नहीं है। इस फ़ंक्शन के साथ, आप Erlang / OTP R16 से पहले पोर्ट आईडी के आधार पर समान वितरण प्राप्त कर सकते हैं।

long driver_binary_dec_refc(ErlDrvBinary *bin)

bin पर संदर्भ गणना को bin और डिक्रिप्ट के बाद पहुंची संदर्भ संख्या को लौटाता है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

ध्यान दें

ड्राइवर बाइनरी की संदर्भ गणना आम तौर पर driver_free_binary को कॉल करके driver_free_binary

यदि संदर्भ संख्या शून्य तक पहुँच जाती है तो driver_binary_dec_refc बाइनरी को मुक्त नहीं करता है। केवल driver_binary_dec_refc उपयोग driver_binary_dec_refc जब आप शून्य की संदर्भ संख्या तक नहीं पहुंचना सुनिश्चित करते हैं।

long driver_binary_get_refc(ErlDrvBinary *bin)

bin पर वर्तमान संदर्भ गणना देता है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

long driver_binary_inc_refc(ErlDrvBinary *bin)

bin पर संदर्भ संख्या बढ़ाता है और वृद्धि के बाद पहुंची संदर्भ संख्या लौटाता है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

ErlDrvTermData driver_caller(ErlDrvPort port)

उस प्रक्रिया की प्रक्रिया आईडी लौटाता है जिसने ड्राइवर को वर्तमान कॉल किया था। कॉलर को वापस डेटा भेजने के लिए driver_send_term आईडी के साथ प्रक्रिया आईडी का उपयोग किया जा सकता है। driver_caller केवल तब मान्य डेटा लौटाता है जब वर्तमान में निम्न ड्राइवर कॉलबैक में से एक में निष्पादित हो रहा हो:

start
erlang:open_port/2 से कॉल किया गया erlang:open_port/2
output
erlang:port_command/2 से कॉल किया गया erlang:send/2 और erlang:port_command/2
outputv
erlang:port_command/2 से कॉल किया गया erlang:send/2 और erlang:port_command/2
control
erlang:port_control/3 से कॉल किया गया erlang:port_control/3
call
erlang:port_call/3 से erlang:port_call/3

ध्यान दें कि यह फ़ंक्शन थ्रेड-सुरक्षित नहीं है, तब भी नहीं जब एसएमपी समर्थन वाले एमुलेटर का उपयोग किया जाता है।

int driver_cancel_timer(ErlDrvPort port)

driver_set_timer साथ एक टाइमर सेट रद्द करता है।

वापसी मान 0

int driver_compare_monitors(const ErlDrvMonitor *monitor1, const ErlDrvMonitor *monitor2)

दो ErlDrvMonitor तुलना करता है। जो भी कारण हो, मॉनिटर पर कुछ कृत्रिम आदेश लगाने के लिए भी इस्तेमाल किया जा सकता है।

0 अगर monitor1 और monitor2 बराबर हैं, तो < 0 अगर monitor1 < monitor2 , और> 0 अगर monitor1 > monitor2

ErlDrvTermData driver_connected(ErlDrvPort port)

पोर्ट स्वामी प्रक्रिया लौटाता है।

ध्यान दें कि यह फ़ंक्शन थ्रेड-सुरक्षित नहीं है, तब भी नहीं जब एसएमपी समर्थन वाले एमुलेटर का उपयोग किया जाता है।

ErlDrvPort driver_create_port(ErlDrvPort port, ErlDrvTermData owner_pid, char* name, ErlDrvData drv_data)

नए पोर्ट को बनाने वाले पोर्ट के समान ड्राइवर कोड को निष्पादित करने वाला एक नया पोर्ट बनाता है।

port
पोर्ट (ड्राइवर उदाहरण) का पोर्ट हैंडल नया पोर्ट बना रहा है।
owner_pid
नए पोर्ट के मालिक बनने के लिए एरलैंग प्रक्रिया की प्रक्रिया आईडी। यह प्रक्रिया नए पोर्ट से जुड़ी होगी। आप आमतौर पर driver_caller(port) का उपयोग driver_caller(port) रूप में करना owner_pid
name
नए पोर्ट का पोर्ट नाम। आप आमतौर पर उसी पोर्ट नाम का उपयोग करना चाहते हैं जैसे ड्राइवर नाम ( driver_name फ़ील्ड)।
drv_data
ड्राइवर-परिभाषित हैंडल जो बाद में पास हो जाता है, ड्राइवर कॉलबैक को कॉल करता है। ध्यान दें कि start को इस नए ड्राइवर उदाहरण के लिए नहीं कहा जाता है। ड्राइवर-परिभाषित हैंडल सामान्य रूप से start में बनाया जाता है जब एक पोर्ट erlang:open_port/2 के माध्यम से बनाया जाता है।

driver_create_port कॉलर को नए बनाए गए पोर्ट में हेरफेर करने की अनुमति दी जाती है जब driver_create_port वापस आ गया है। जब port level locking उपयोग किया जाता है, तो बनाने वाले पोर्ट को केवल नए बनाए गए पोर्ट को हेरफेर करने की अनुमति दी जाती है जब तक कि वर्तमान ड्राइवर कॉलबैक, जिसे एमुलेटर द्वारा कॉल किया जाता है, रिटर्न करता है।

int driver_demonitor_process(ErlDrvPort port, const ErlDrvMonitor *monitor)

पहले बनाया गया एक मॉनिटर रद्द करता है।

0 अगर कोई मॉनिटर हटा दिया गया था और> 0 अगर मॉनिटर अब मौजूद नहीं है, तो लौटाता है।

ErlDrvSizeT driver_deq(ErlDrvPort port, ErlDrvSizeT size)

size बाइट द्वारा ड्राइवर कतार में हेड पॉइंटर को आगे बढ़ाकर डेटा डिलीट करता है । कतार में डेटा डीलॉक्ड है।

सफलता पर कतार में शेष बाइट्स की संख्या देता है, अन्यथा -1

यह समारोह किसी भी धागे से कहा जा सकता है एक ErlDrvPDL साथ जुड़े port कॉल के दौरान बुला धागे से बंद है।

int driver_enq(ErlDrvPort port, char* buf, ErlDrvSizeT len)

ड्रायवर कतार में डेटा एन्क्लेव करता है। डेटा buf को कॉपी ( len बाइट्स) में रखा गया है और ड्राइवर कतार के अंत में रखा गया है। ड्राइवर कतार का उपयोग आम तौर पर FIFO तरीके से किया जाता है।

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

जब कतार में डेटा होता है, तो ड्राइवर तब तक बंद नहीं होता जब तक कि कतार खाली न हो।

वापसी मूल्य है 0

यह समारोह किसी भी धागे से कहा जा सकता है एक ErlDrvPDL साथ जुड़े port कॉल के दौरान बुला धागे से बंद है।

int driver_enq_bin(ErlDrvPort port, ErlDrvBinary *bin, ErlDrvSizeT offset, ErlDrvSizeT len)

ड्राइवर कतार में एक ड्राइवर बाइनरी में बाधक। में डेटा bin पर offset लंबाई के साथ len कतार के अंत में रखा गया है। यह फ़ंक्शन सबसे अधिक बार से तेज़ है driver_enq , क्योंकि किसी भी डेटा को कॉपी नहीं किया जाना चाहिए।

यह समारोह किसी भी धागे से कहा जा सकता है एक ErlDrvPDL साथ जुड़े port कॉल के दौरान बुला धागे से बंद है।

वापसी मूल्य है 0

int driver_enqv(ErlDrvPort port, ErlIOVec *ev, ErlDrvSizeT skip)

ड्रायवर कतार के अंत में, इसके ev पहले skip बाइट्स को छोड़ते हुए, डेटा को एंकेज़ करता है । यह इससे भी तेज़ है driver_enq , क्योंकि कोई भी डेटा कॉपी नहीं होना चाहिए।

वापसी मूल्य है 0

यह समारोह किसी भी धागे से कहा जा सकता है एक ErlDrvPDL साथ जुड़े port कॉल के दौरान बुला धागे से बंद है।

int driver_failure(ErlDrvPort port, int error) int driver_failure_atom(ErlDrvPort port, char *string) int driver_failure_posix(ErlDrvPort port, int error)

Erlang को संकेत है कि ड्राइवर ने एक त्रुटि का सामना किया है और उसे बंद किया जाना है। पोर्ट को बंद कर दिया जाता है और टपल {'EXIT', error, Err} को पोर्ट ओनर प्रोसेस में भेज दिया जाता है, जहां एरर एटम ( driver_failure_atom और driver_failure_posix ) या एक पूर्णांक ( driver_failure ) होता है।

ड्राइवर को केवल तब ही विफल होना है जब गंभीर त्रुटि स्थितियों में, जब ड्राइवर संभवतः खुला नहीं रख सकता है, उदाहरण के लिए, बफर आवंटन मेमोरी से बाहर हो जाता है। सामान्य त्रुटियों के लिए त्रुटि कोड भेजना अधिक उपयुक्त है driver_output

वापसी मूल्य है 0

int driver_failure_eof(ErlDrvPort port)

इरलांग को संकेत है कि ड्राइवर को ईओएफ का सामना करना पड़ा है और इसे बंद करना है, जब तक कि पोर्ट को विकल्प के साथ नहीं खोला गया था eof , जिस स्थिति eof में पोर्ट भेजा जाता है। अन्यथा पोर्ट बंद है और 'EXIT' पोर्ट मालिक प्रक्रिया के लिए एक संदेश भेजा जाता है।

वापसी मूल्य है 0

void driver_free(void *ptr)

द्वारा इंगित की गई यादों को पूरा करता है ptr । स्मृति के साथ आवंटित किया गया है driver_alloc । सभी आवंटित की गई मेमोरी को केवल एक बार ही निपटाया जाना है। ड्राइवरों में कचरा संग्रहण नहीं है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void driver_free_binary(ErlDrvBinary *bin)

bin पहले से आवंटित एक ड्राइवर बाइनरी को पेड़ करता है driver_alloc_binary । चूंकि एरलैंग में बायनेरिज़ को संदर्भ में गिना जाता है, बाइनरी अभी भी चारों ओर हो सकती है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

ErlDrvTermData driver_get_monitored_process(ErlDrvPort port, const ErlDrvMonitor *monitor)

एक जीवित मॉनिटर के साथ जुड़ी प्रक्रिया आईडी लौटाता है। इसका उपयोग process_exit कॉलबैक में बाहर निकलने की प्रक्रिया के लिए प्रक्रिया पहचान प्राप्त करने के लिए किया जा सकता है।

driver_term_nil यदि मॉनीटर अब मौजूद नहीं है, तो लौटाता है।

int driver_get_now(ErlDrvNowData *now)

चेतावनी

इस फ़ंक्शन को पदावनत किया जाता है। इसका प्रयोग न करें। का प्रयोग करें erl_drv_monotonic_time (शायद के साथ संयोजन में erl_drv_time_offset ) के बजाय।

पैरामीटर द्वारा बताई गई मेमोरी में टाइम स्टैम्प पढ़ता है now । विशिष्ट क्षेत्रों के बारे में जानकारी के लिए, देखें ErlDrvNowData

रिटर्न वैल्यू 0 तब तक है , जब तक कि now पॉइंटर अमान्य नहीं है, जिस स्थिति में यह <है 0

int driver_lock_driver(ErlDrvPort port)

port एमुलेटर प्रक्रिया के बाकी समय के लिए मेमोरी में पोर्ट द्वारा उपयोग किए गए ड्राइवर को लॉक करता है । इस कॉल के बाद, ड्राइवर एरलांग के स्टेटिकली लिंक्ड-इन ड्राइवरों में से एक के रूप में व्यवहार करता है।

ErlDrvTermData driver_mk_atom(char* string)

एक परमाणु नाम देता है string । परमाणु बनाया जाता है और बदलता नहीं है, इसलिए वापसी मूल्य को बचाया और पुन: उपयोग किया जा सकता है, जो कई बार परमाणु को देखने की तुलना में तेज है।

ध्यान दें कि इस समारोह है नहीं थ्रेड-सुरक्षित, यहां तक कि नहीं जब SMP समर्थन के साथ एमुलेटर प्रयोग किया जाता है।

ErlDrvTermData driver_mk_port(ErlDrvPort port)

एक बंदरगाह संभाल को Erlang शब्द के प्रारूप में रूपांतरित करता है, जो प्रयोग करने योग्य है erl_drv_output_term और erl_drv_send_term

ध्यान दें कि इस समारोह है नहीं थ्रेड-सुरक्षित, यहां तक कि नहीं जब SMP समर्थन के साथ एमुलेटर प्रयोग किया जाता है।

int driver_monitor_process(ErlDrvPort port, ErlDrvTermData process, ErlDrvMonitor *monitor)

एक ड्राइवर से एक प्रक्रिया की निगरानी शुरू करता है। जब एक प्रक्रिया की निगरानी की जाती है, process_exit तो driver_entry संरचना में प्रदान किए गए कॉलबैक के लिए कॉल में एक प्रक्रिया से बाहर निकलता है । ErlDrvMonitor संरचना में भर जाता है, बाद में हटाने या तुलना के लिए।

पैरामीटर process पहले के कॉल driver_caller या driver_connected कॉल के लिए रिटर्न वैल्यू है ।

0 यदि कोई कॉलबैक प्रदान नहीं किया गया है, तो सफलता पर रिटर्न , और यदि प्रक्रिया अब जीवित नहीं है, तो 0।

int driver_output(ErlDrvPort port, char *buf, ErlDrvSizeT len)

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

डेटा पोर्ट स्वामी प्रक्रिया संदेश कतार में पंक्तिबद्ध है। ध्यान दें कि यह एमुलेटर (ड्राइवर और एमुलेटर एक ही धागे में चलते हैं) के लिए उपज नहीं है।

पैरामीटर buf डेटा भेजने के लिए इंगित करता है, और len बाइट्स की संख्या है।

सभी आउटपुट कार्यों के लिए वापसी मूल्य 0 सामान्य उपयोग के लिए है। यदि ड्राइवर को वितरण के लिए उपयोग किया जाता है, तो यह विफल हो सकता है और वापस लौट सकता है -1

int driver_output_binary(ErlDrvPort port, char *hbuf, ErlDrvSizeT hlen, ErlDrvBinary* bin, ErlDrvSizeT offset, ErlDrvSizeT len)

ड्राइवर बाइनरी से पोर्ट मालिक प्रक्रिया के लिए डेटा भेजता है। इसमें हेडर बफ़र ( hbuf और hlen ) जैसा है driver_output2 । पैरामीटर hbuf हो सकता है NULL

पैरामीटर offset बाइनरी में एक ऑफसेट है और len भेजने के लिए बाइट्स की संख्या है।

ड्राइवर बायनेरिज़ के साथ बनाए जाते हैं driver_alloc_binary

हेडर में डेटा को सूची के रूप में और बाइनरी को सूची की पूंछ में एर्लांग बाइनरी के रूप में भेजा जाता है।

उदाहरण के लिए, यदि hlen है 2 , तो पोर्ट मालिक प्रक्रिया प्राप्त करता है [H1, H2 | <<T>>]

वापसी मूल्य 0 सामान्य उपयोग के लिए है।

ध्यान दें कि, एरलांग में बाइनरी सिंटैक्स का उपयोग करके, ड्राइवर एप्लिकेशन बाइनरी से सीधे हेडर से मेल कर सकता है, इसलिए हेडर को बाइनरी में रखा जा सकता है, और hlen इसे सेट किया जा सकता है 0

int driver_output_term(ErlDrvPort port, ErlDrvTermData* term, int n)

चेतावनी

इस फ़ंक्शन को पदावनत किया जाता है। erl_drv_send_term इसके बजाय उपयोग करें ।

पैरामीटर term और n के रूप में काम करते हैं erl_drv_output_term

ध्यान दें कि इस समारोह है नहीं थ्रेड-सुरक्षित, यहां तक कि नहीं जब SMP समर्थन के साथ एमुलेटर प्रयोग किया जाता है।

int driver_output2(ErlDrvPort port, char *hbuf, ErlDrvSizeT hlen, char *buf, ErlDrvSizeT len)

पोर्ट सेटिंग्स की परवाह किए बिना सूची के रूप hbuf में पहले (लंबाई में hlen ) डेटा भेजता है । फिर buf बाइनरी या सूची के रूप में भेजता है । उदाहरण के लिए, यदि hlen है 3 , तो पोर्ट मालिक प्रक्रिया प्राप्त करता है [H1, H2, H3 | T]

सूची शीर्षलेख के रूप में डेटा भेजने की बात यह है कि प्राप्त आंकड़ों पर मिलान करने की सुविधा है।

वापसी मूल्य 0 सामान्य उपयोग के लिए है।

int driver_outputv(ErlDrvPort port, char* hbuf, ErlDrvSizeT hlen, ErlIOVec *ev, ErlDrvSizeT skip)

ev पोर्ट स्वामी प्रक्रिया में I / O वेक्टर से डेटा भेजता है। इसमें हेडर बफर ( hbuf और hlen ) की तरह है driver_output2

पैरामीटर सिर से वेक्टर skip को छोड़ने के लिए कई बाइट्स है ev

आपको ErlIOVec ड्राइवर कतार (नीचे देखें) और outputv ड्राइवर प्रविष्टि फ़ंक्शन से प्रकार के वैक्टर मिलते हैं । आप उन्हें स्वयं भी बना सकते हैं, यदि आप ErlDrvBinary एक साथ कई बफ़र भेजना चाहते हैं । अक्सर इसका उपयोग करना तेज होता है driver_output या।

उदाहरण के लिए, यदि hlen है 2 और ev तीन बायनेरिज़ की एक सरणी को इंगित करता है, तो पोर्ट मालिक प्रक्रिया प्राप्त करता है [H1, H2, <<B1>>, <<B2>> | <<B3>>]

वापसी मूल्य 0 सामान्य उपयोग के लिए है।

के लिए टिप्पणी driver_output_binary भी लागू होती है driver_outputv

ErlDrvPDL driver_pdl_create(ErlDrvPort port)

के साथ जुड़े एक पोर्ट डेटा लॉक बनाता है port

ध्यान दें

एक बार पोर्ट डेटा लॉक बन जाने के बाद, इसे चालक की कतार पर सभी परिचालनों के दौरान लॉक किया जाना चाहिए port

सफलता पर एक नया निर्मित पोर्ट डेटा लॉक लौटाता है, अन्यथा NULL port यदि कोई पोर्ट डेटा लॉक पहले से संबद्ध है, तो फ़ंक्शन विफल रहता है port

long driver_pdl_dec_refc(ErlDrvPDL pdl)

पोर्ट डेटा लॉक की संदर्भ गणना को तर्क ( pdl ) के रूप में पारित किया ।

डिक्रिप्शन के बाद वर्तमान संदर्भ गणना वापस आ गई है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

long driver_pdl_get_refc(ErlDrvPDL pdl)

पोर्ट डेटा लॉक की वर्तमान संदर्भ गणना को तर्क ( pdl ) के रूप में पारित करता है ।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

long driver_pdl_inc_refc(ErlDrvPDL pdl)

पोर्ट डेटा लॉक के संदर्भ गणना को तर्क के रूप में पारित किया गया ( pdl )।

वेतन वृद्धि के बाद वर्तमान संदर्भ गणना वापस आ गई है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void driver_pdl_lock(ErlDrvPDL pdl)

पोर्ट डेटा लॉक को लॉजिक ( pdl ) के रूप में लॉक किया जाता है ।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void driver_pdl_unlock(ErlDrvPDL pdl)

पोर्ट डेटा लॉक को तर्क ( pdl ) के रूप में अनलॉक करता है ।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

SysIOVec *driver_peekq(ErlDrvPort port, int *vlen)

ड्रायवर के रूप में ड्रायवर कतार को पुनः सरणी के सरणी में SysIOVec रखता है। यह तत्वों की संख्या भी लौटाता है vlen । यह कतार से डेटा प्राप्त करने के दो तरीकों में से एक है।

इस फ़ंक्शन द्वारा कतार से कुछ भी नहीं निकाला जाता है, जिसे इसके साथ किया जाना चाहिए driver_deq

लौटे सरणी यूनिक्स सिस्टम कॉल के साथ उपयोग करने के लिए उपयुक्त है writev

यह समारोह किसी भी धागे से कहा जा सकता है एक ErlDrvPDL साथ जुड़े port कॉल के दौरान बुला धागे से बंद है।

ErlDrvSizeT driver_peekqv(ErlDrvPort port, ErlIOVec *ev)

एक आपूर्ति में चालक कतार को पुनः प्राप्त करता है ErlIOVec ev । यह कतार का आकार भी लौटाता है। यह कतार से डेटा प्राप्त करने के दो तरीकों में से एक है।

यदि ev ऐसा है NULL , तो सभी -1 प्रकार के कलाकारों को ErlDrvSizeT लौटा दिया जाता है।

इस फ़ंक्शन द्वारा कतार से कुछ भी नहीं निकाला जाता है, जिसे इसके साथ किया जाना चाहिए driver_deq

यह समारोह किसी भी धागे से कहा जा सकता है एक ErlDrvPDL साथ जुड़े port कॉल के दौरान बुला धागे से बंद है।

int driver_pushq(ErlDrvPort port, char* buf, ErlDrvSizeT len)

चालक कतार के सिर पर डेटा डालता है। डेटा buf को कॉपी ( len बाइट्स) में रखा गया है और कतार की शुरुआत में रखा गया है।

वापसी मूल्य है 0

यह समारोह किसी भी धागे से कहा जा सकता है एक ErlDrvPDL साथ जुड़े port कॉल के दौरान बुला धागे से बंद है।

int driver_pushq_bin(ErlDrvPort port, ErlDrvBinary *bin, ErlDrvSizeT offset, ErlDrvSizeT len)

ड्राइवर कतार के सिर पर लंबाई के साथ bin , बाइनरी में डेटा डालता है । यह सबसे अधिक बार से तेज है , क्योंकि कोई भी डेटा कॉपी नहीं किया जाना चाहिए। offset len driver_pushq

यह समारोह किसी भी धागे से कहा जा सकता है एक ErlDrvPDL साथ जुड़े port कॉल के दौरान बुला धागे से बंद है।

वापसी मूल्य है 0

int driver_pushqv(ErlDrvPort port, ErlIOVec *ev, ErlDrvSizeT skip)

ड्राइवर कतार के सिर पर, इसके ev पहले skip बाइट्स को छोड़ते हुए, डेटा डालता है । यह इससे भी तेज़ है driver_pushq , क्योंकि कोई भी डेटा कॉपी नहीं होना चाहिए।

वापसी मूल्य है 0

यह समारोह किसी भी धागे से कहा जा सकता है एक ErlDrvPDL साथ जुड़े port कॉल के दौरान बुला धागे से बंद है।

int driver_read_timer(ErlDrvPort port, unsigned long *time_left)

एक टाइमर के वर्तमान समय को पढ़ता है, और परिणाम को अंदर रखता है time_left । यह समय समाप्त होने से पहले मिलीसेकंड में समय है।

वापसी मूल्य है 0

void *driver_realloc(void *ptr, ErlDrvSizeT size)

एक मेमोरी ब्लॉक का आकार, या तो जगह में, या एक नया ब्लॉक आवंटित करके, डेटा की प्रतिलिपि बनाकर, और पुराने ब्लॉक को मुक्त करता है। एक पॉइंटर को वास्तविक मेमोरी में लौटा दिया जाता है। विफलता (स्मृति से बाहर) पर, NULL लौटा दिया जाता है। (यह अक्सर के लिए एक आवरण है realloc ।)

यह फ़ंक्शन थ्रेड-सुरक्षित है।

ErlDrvBinary *driver_realloc_binary(ErlDrvBinary *bin, ErlDrvSizeT size)

डेटा को रखते हुए, एक ड्राइवर बाइनरी का आकार बदलता है।

सफलता पर रिसाइज्ड ड्राइवर बाइनरी लौटाता है। रिटर्न NULL (स्मृति से बाहर) विफलता पर।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

int driver_select(ErlDrvPort port, ErlDrvEvent event, int mode, int on)

इस फ़ंक्शन का उपयोग ड्राइवरों द्वारा जांच के लिए घटनाओं के साथ एमुलेटर प्रदान करने के लिए किया जाता है। यह एमुलेटर को ड्राइवर को कॉल करने में सक्षम बनाता है जब कुछ अतुल्यकालिक रूप से हुआ है।

पैरामीटर event OS-विशिष्ट ईवेंट ऑब्जेक्ट की पहचान करता है। यूनिक्स प्रणालियों पर, कार्यों select / poll का उपयोग किया जाता है। ईवेंट ऑब्जेक्ट सॉकेट या पाइप (या अन्य ऑब्जेक्ट जो select / poll का उपयोग कर सकता है) होना चाहिए। विंडोज पर, Win32 API फ़ंक्शन WaitForMultipleObjects का उपयोग किया जाता है। यह ईवेंट ऑब्जेक्ट पर अन्य प्रतिबंध लगाता है; Win32 SDK प्रलेखन देखें।

पैरामीटर on हो रहा है 1 घटनाओं की स्थापना के लिए और 0 उन्हें साफ़ करने के लिए।

पैरामीटर mode एक बिटवाइज़ या का संयोजन है ERL_DRV_READ , ERL_DRV_WRITE और ERL_DRV_USE । पहले दो निर्दिष्ट करें कि क्या पढ़ने की घटनाओं और / या घटनाओं को लिखने के लिए प्रतीक्षा करें। एक पढ़ी गई ईवेंट कॉल ready_input और एक वायर्ड राइट ईवेंट कॉल ready_output

ध्यान दें

कुछ OS (विंडोज़) पढ़ने और लिखने की घटनाओं के बीच अंतर नहीं करते हैं। निकाल दिया घटना के लिए कॉलबैक केवल के मूल्य पर निर्भर करता है mode

ERL_DRV_USE निर्दिष्ट करता है कि क्या हम ईवेंट ऑब्जेक्ट का उपयोग कर रहे हैं या यदि हम इसे बंद करना चाहते हैं। एसएमपी समर्थन के साथ एक एमुलेटर पर, सभी घटनाओं को साफ़ करने के लिए सुरक्षित नहीं है और फिर driver_select वापस आने के बाद इवेंट ऑब्जेक्ट को बंद करें । एक अन्य धागा अभी भी आंतरिक रूप से ईवेंट ऑब्जेक्ट का उपयोग कर सकता है। किसी ईवेंट ऑब्जेक्ट को सुरक्षित रूप से बंद करने के लिए, driver_select साथ कॉल करें ERL_DRV_USE और on==0 , जो सभी ईवेंट्स को साफ़ करता है और फिर कॉल stop_select या शेड्यूल करता है, जिसे इवेंट ऑब्जेक्ट को बंद करने के लिए सुरक्षित होने पर कॉल किया जाए। ERL_DRV_USE ईवेंट ऑब्जेक्ट के लिए पहले ईवेंट के साथ सेट किया जाना है। यह सेट ERL_DRV_USE करने के लिए हानिरहित है भले ही यह पहले से ही किया गया हो। सभी ईवेंट साफ़ करना लेकिन ERL_DRV_USE सेट रखना यह इंगित करता है कि हम ईवेंट ऑब्जेक्ट का उपयोग कर रहे हैं और संभवतः इसके लिए ईवेंट फिर से सेट करेंगे।

ध्यान दें

ERL_DRV_USE Erlang / OTP R13 में जोड़ा गया था। पुराने ड्राइवर अभी भी पहले की तरह काम करते हैं, लेकिन यह उपयोग करने के लिए उन्हें अपडेट करने ERL_DRV_USE और stop_select यह सुनिश्चित करने के लिए सिफारिश की जाती है कि इवेंट ऑब्जेक्ट्स को सुरक्षित तरीके से बंद कर दिया जाए।

वापसी मूल्य 0 , जब तक ready_input / ready_output है NULL , जिस स्थिति में है -1

int driver_send_term(ErlDrvPort port, ErlDrvTermData receiver, ErlDrvTermData* term, int n)

चेतावनी

इस फ़ंक्शन को पदावनत किया जाता है। erl_drv_send_term इसके बजाय उपयोग करें ।

ध्यान दें

इस फ़ंक्शन के मापदंडों को रनटाइम सिस्टम द्वारा ठीक से जांच नहीं किया जा सकता है जब मनमाने धागे द्वारा निष्पादित किया जाता है। यह फ़ंक्शन को तब विफल करने का कारण बन सकता है जब इसे करना चाहिए।

पैरामीटर term और n के रूप में काम करते हैं erl_drv_output_term

यह फ़ंक्शन केवल थ्रेड-सुरक्षित है जब एसएमपी समर्थन वाले एमुलेटर का उपयोग किया जाता है।

int driver_set_timer(ErlDrvPort port, unsigned long time)

ड्राइवर पर एक टाइमर सेट करता है, जो समय समाप्त होने पर ड्राइवर को गिना और कॉल करेगा। पैरामीटर time टाइमर समाप्त होने से पहले मिलीसेकंड में समय है।

जब टाइमर पहुंचता है 0 और समाप्त हो जाता है, तो ड्राइवर प्रविष्टि फ़ंक्शन timeout कहा जाता है।

ध्यान दें कि प्रत्येक चालक के उदाहरण पर केवल एक टाइमर मौजूद है; नया टाइमर सेट करने से पुराने की जगह बदल जाती है।

वापसी मान है 0 , जब तक कि timeout ड्राइवर फ़ंक्शन नहीं है NULL , जिस स्थिति में यह है -1

ErlDrvSizeT driver_sizeq(ErlDrvPort port)

ड्राइवर कतार में वर्तमान में बाइट्स की संख्या देता है।

यह समारोह किसी भी धागे से कहा जा सकता है एक ErlDrvPDL साथ जुड़े port कॉल के दौरान बुला धागे से बंद है।

void driver_system_info(ErlDrvSysInfo *sys_info_ptr, size_t size)

ErlDrvSysInfo पहले तर्क द्वारा निर्दिष्ट संरचना में एरलंग रनटाइम सिस्टम के बारे में जानकारी लिखता है। दूसरा तर्क ErlDrvSysInfo संरचना के आकार का होना है , अर्थात sizeof(ErlDrvSysInfo)

विशिष्ट क्षेत्रों के बारे में जानकारी के लिए, देखें ErlDrvSysInfo

ErlDrvSizeT driver_vec_to_buf(ErlIOVec *ev, char *buf, ErlDrvSizeT len)

आकार ev के बफ़र के क्रम में कॉपी करके , डेटा के कई सेगमेंट एकत्र करता है । buf len

यदि ड्राइवर से पोर्ट स्वामी प्रक्रिया में डेटा भेजा जाना है, तो इसका उपयोग करना तेज़ है driver_outputv

वापसी मान अंतरिक्ष बफर, कि है, अगर में छोड़ दिया है ev की तुलना में कम होता है len बाइट्स यह अंतर है, और अगर ev होता है len बाइट या अधिक है, यह है 0 । यदि बाइनरी सिंटैक्स बाइनरी से सीधे पूर्णांक का निर्माण कर सकता है, तो यह तेजी से होता है।

void erl_drv_busy_msgq_limits(ErlDrvPort port, ErlDrvSizeT *low, ErlDrvSizeT *high)

सेट और हो जाता है कि पोर्ट संदेश कतार के व्यस्त राज्य को नियंत्रित करने के लिए इस्तेमाल किया जाएगा।

पोर्ट संदेश कतार व्यस्त अवस्था में सेट की जाती है जब संदेश कतार पर कतारबद्ध कमांड डेटा की मात्रा high सीमा तक पहुँच जाती है। पोर्ट संदेश कतार एक व्यस्त स्थिति में सेट की गई है जब संदेश कतार पर पंक्तिबद्ध कमांड डेटा की मात्रा low सीमा से नीचे आती है। कमांड डेटा इस संदर्भ में Port ! {Owner, {command, Data}} या तो या पोर्ट का उपयोग कर पोर्ट के लिए पारित डेटा है port_command/[2,3] । ध्यान दें कि ये सीमाएं केवल कमांड डेटा की चिंता करती हैं जो अभी तक पोर्ट तक नहीं पहुंची हैं। busy port सुविधा डेटा है कि बंदरगाह तक पहुँच गया है के लिए इस्तेमाल किया जा सकता है।

मान्य सीमा सीमा में मूल्य हैं [ERL_DRV_BUSY_MSGQ_LIM_MIN, ERL_DRV_BUSY_MSGQ_LIM_MAX] । सीमाएँ स्वचालित रूप से समायोजित की जाती हैं। यही है, सिस्टम मूल्यों को समायोजित करता है ताकि उपयोग की गई कम सीमा उपयोग की गई उच्च सीमा से कम या बराबर हो। डिफ़ॉल्ट रूप से उच्च सीमा 8 kB है और निम्न सीमा 4 kB है।

एक पॉइंटर को एक पूर्णांक चर के मान से युक्त करके ERL_DRV_BUSY_MSGQ_READ_ONLY , वर्तमान में उपयोग की जाने वाली सीमा को पूर्णांक चर पर वापस पढ़ा और लिखा जाता है। एक वैध सीमा वाले एक पूर्णांक चर के लिए एक पॉइंटर पास करके एक नई सीमा निर्धारित की जा सकती है। पारित मूल्य आंतरिक सीमा को लिखा जाता है। आंतरिक सीमा को तब समायोजित किया जाता है। इसके बाद समायोजित सीमा को पूर्णांक चर पर वापस लिखा जाता है जिसमें से नया मान पढ़ा गया था। मान बाइट्स में हैं।

व्यस्त संदेश कतार सुविधा की स्थापना करके या तो निष्क्रिय किया जा सकता ERL_DRV_FLAG_NO_BUSY_MSGQ driver_flags में driver_entry चालक द्वारा प्रयोग किया जाता है, या के साथ इस समारोह को फोन करके ERL_DRV_BUSY_MSGQ_DISABLED एक सीमा के रूप में (या तो कम या उच्च)। जब यह सुविधा अक्षम कर दी गई है, तो इसे फिर से सक्षम नहीं किया जा सकता है। सीमाएं पढ़ते समय, ERL_DRV_BUSY_MSGQ_DISABLED यदि यह सुविधा अक्षम कर दी गई है , तो दोनों हैं ।

पोर्ट पर कमांड डेटा भेजने वाली प्रक्रियाएं निलंबित कर दी जाती हैं यदि पोर्ट या तो व्यस्त है या पोर्ट मैसेज कतार व्यस्त है। जब पोर्ट या पोर्ट संदेश कतार व्यस्त नहीं है, तो निलंबित प्रक्रियाएँ फिर से शुरू हो जाती हैं।

व्यस्त पोर्ट कार्यक्षमता के बारे में जानकारी के लिए, देखें set_busy_port

void erl_drv_cond_broadcast(ErlDrvCond *cnd)

एक शर्त चर पर प्रसारण। यही है, यदि अन्य थ्रेड्स पर प्रसारित होने वाले स्थिति चर पर इंतजार कर रहे हैं, तो वे सभी जागृत हैं।

cnd पर प्रसारित करने के लिए एक शर्त चर के लिए एक सूचक है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

ErlDrvCond *erl_drv_cond_create(char *name)

एक स्थिति चर बनाता है और इसे एक पॉइंटर लौटाता है।

name निर्मित स्थिति चर की पहचान करने वाला एक स्ट्रिंग है। इसका उपयोग नियोजित भविष्य डिबग कार्यक्षमता में स्थिति चर की पहचान करने के लिए किया जाता है।

NULL असफलता पर लौटाता है। ड्राईवर को उतारने से पहले हालत परिवर्तनशील बनाने वाला चालक इसे नष्ट करने के लिए जिम्मेदार है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_cond_destroy(ErlDrvCond *cnd)

पहले से बनाए गए एक शर्त चर को नष्ट कर देता है erl_drv_cond_create

cnd को नष्ट करने के लिए एक स्थिति चर के लिए एक सूचक है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

char *erl_drv_cond_name(ErlDrvCond *cnd)

स्थिति के नाम पर एक सूचक लौटाता है।

cnd एक प्रारंभिक स्थिति के लिए एक संकेतक है।

ध्यान दें

यह फ़ंक्शन केवल डीबगिंग उद्देश्यों के लिए लक्षित है।

void erl_drv_cond_signal(ErlDrvCond *cnd)

एक शर्त चर पर संकेत। यही कारण है, अन्य थ्रेड संकेत जा रहा है, हालत चर पर इंतजार कर रहे हैं अगर एक उनमें से जगाया है।

cnd संकेत करने के लिए एक स्थिति चर का सूचक है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_cond_wait(ErlDrvCond *cnd, ErlDrvMutex *mtx)

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

cnd प्रतीक्षा करने के लिए एक स्थिति चर का सूचक है। mtx प्रतीक्षा करते समय अनलॉक करने के लिए एक म्यूटेक्स का सूचक है।

ध्यान दें

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

यह फ़ंक्शन थ्रेड-सुरक्षित है।

int erl_drv_consume_timeslice(ErlDrvPort port, int percent)

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

port
निष्पादन योग्य पोर्ट का पोर्ट हैंडल।
percent
प्रतिशत में पूर्ण समय-स्लाइस के अनुमानित भस्म अंश।

समय को अंश के रूप में निर्दिष्ट किया गया है, प्रतिशत में, एक पूर्णकालिक टाइम-स्लाइस के लिए जो पोर्ट को निष्पादित करने की अनुमति है, इससे पहले कि वह सीपीयू को अन्य रनवेबल पोर्ट या प्रक्रियाओं के लिए समर्पण कर सके। मान्य सीमा है [1, 100] । शेड्यूलिंग टाइम-स्लाइस एक सटीक इकाई नहीं है, लेकिन आमतौर पर लगभग 1 मिलीसेकंड के लिए अनुमानित किया जा सकता है।

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

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

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

warning इस मैनुअल पेज की शुरुआत में महत्वपूर्ण पाठ भी देखें ।

ErlDrvTime erl_drv_convert_time_unit(ErlDrvTime val, ErlDrvTimeUnit from, ErlDrvTimeUnit to)

val टाइम यूनिट के मूल्य को टाइम यूनिट from के अनुरूप मान में परिवर्तित करता है to । फर्श फ़ंक्शन का उपयोग करके परिणाम को गोल किया जाता है।

val
के लिए समय इकाई बदलने के लिए मूल्य।
from
की समय इकाई val
to
लौटे मूल्य की समय इकाई।

ERL_DRV_TIME_ERROR यदि अमान्य समय इकाई तर्क के साथ कॉल किया जाता है तो वापस लौटाता है।

यह भी देखें ErlDrvTime और ErlDrvTimeUnit

int erl_drv_equal_tids(ErlDrvTid tid1, ErlDrvTid tid2)

दो धागे पहचानकर्ताओं की तुलना करता है, tid1 और tid2 , समानता के लिए।

0 यह लौटाता है कि वे समान नहीं हैं, और 0 यदि वे समान हैं तो एक मूल्य नहीं ।

ध्यान दें

एक थ्रेड पहचानकर्ता एक थ्रेड समाप्त होने के बाद बहुत जल्दी से पुन: उपयोग किया जा सकता है। इसलिए, यदि थ्रेड आइडेंटिफ़ायर को सहेजे जाने के बाद से जुड़े थ्रेड आइडेंटिफ़ायर में से एक थ्रेड समाप्त हो गया है, तो परिणाम erl_drv_equal_tids संभवतः अपेक्षित परिणाम नहीं देता है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

int erl_drv_getenv(const char *key, char *value, size_t *value_size)

पर्यावरण चर का मान निकालता है।

key
एक NULL -terminated स्ट्रिंग वातावरण चर के नाम वाले।
value
एक आउटपुट बफर के लिए एक सूचक।
value_size
पूर्णांक के लिए एक सूचक। पूर्णांक का उपयोग इनपुट और आउटपुट आकार (नीचे देखें) पास करने के लिए किया जाता है।

जब इस फ़ंक्शन को कहा जाता है, *value_size तो value बफर के आकार को शामिल करना है ।

सफलता पर, 0 लौटाया जाता है, पर्यावरण चर का मान value बफर को लिखा गया है , और बफर को लिखे गए मान की *value_size स्ट्रिंग लंबाई (समाप्ति NULL वर्ण को छोड़कर ) शामिल है value

विफलता पर, अर्थात्, ऐसा कोई पर्यावरण चर नहीं मिला, एक मान < 0 वापस आ गया है। जब value बफ़र का आकार बहुत छोटा होता है, तो एक मान> 0 लौटा दिया जाता है और *value_size उसे आवश्यक बफ़र आकार में सेट कर दिया जाता है।

चेतावनी

यह फ़ंक्शन उपयोग किए गए उत्सर्जित वातावरण को पढ़ता है os:getenv/1 और libc getenv(3) या समान द्वारा उपयोग किए जाने वाले वातावरण को नहीं । जिन ड्राइवरों को आवश्यकता है कि ये सिंक में हैं उन्हें स्वयं ऐसा करने की आवश्यकता होगी, लेकिन ध्यान रखें कि उन्हें एक कारण के लिए अलग किया गया है; getenv(3) और इसके दोस्त थ्रेड-सुरक्षित नहीं हैं और एमुलेटर को दुर्व्यवहार या क्रैश करने के लिए असंबंधित कोड हो सकते हैं।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_init_ack(ErlDrvPort port, ErlDrvData res)

पोर्ट की शुरुआत को स्वीकार करता है।

port
पोर्ट (ड्राइवर उदाहरण) की पोर्ट हैंडल पावती कर रही है।
res
पोर्ट आरंभीकरण का परिणाम है। वापसी मान के समान मान हो सकते हैं start , अर्थात, त्रुटि कोड या जो ErlDrvData कि इस पोर्ट के लिए उपयोग किया जाना है।

जब इस फ़ंक्शन को कॉल किया जाता है तो आरंभिक erlang:open_port कॉल वापस आ जाता है जैसे कि start फ़ंक्शन को अभी कॉल किया गया था। इसका उपयोग केवल तब किया जा सकता है जब driver_flags लिंक-इन ड्राइवर पर ध्वज सेट किया गया हो।

ErlDrvTime erl_drv_monotonic_time(ErlDrvTimeUnit time_unit)

लौटता है Erlang monotonic time । ध्यान दें कि नकारात्मक मूल्य असामान्य नहीं हैं।

time_unit लौटाए गए मूल्य की समय इकाई है।

ERL_DRV_TIME_ERROR यदि कोई अमान्य समय इकाई तर्क के साथ कहा जाता है, या यदि वह थ्रेड से कॉल किया जाता है, जो कोई शेड्यूलर थ्रेड नहीं है, तो लौटाता है

यह भी देखें ErlDrvTime और ErlDrvTimeUnit

ErlDrvMutex *erl_drv_mutex_create(char *name)

एक म्यूटेक्स बनाता है और इसे एक पॉइंटर लौटाता है।

name निर्मित म्यूटेक्स की पहचान करने वाला एक स्ट्रिंग है। इसका उपयोग म्यूटेक्स को नियोजित भविष्य डिबग कार्यक्षमता में पहचानने के लिए किया जाता है।

NULL असफलता पर लौटाता है। ड्राइवर को उतारने से पहले म्यूटेक्स बनाने वाला ड्राइवर इसे नष्ट करने के लिए जिम्मेदार है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_mutex_destroy(ErlDrvMutex *mtx)

पहले से बनाए गए म्यूटेक्स को नष्ट कर देता है erl_drv_mutex_create । म्यूटेक्स को नष्ट होने से पहले एक अनलॉक स्थिति में होना चाहिए।

mtx नष्ट करने के लिए म्यूटेक्स का सूचक है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_mutex_lock(ErlDrvMutex *mtx)

एक म्यूटेक्स को लॉक करता है। कॉलिंग थ्रेड को तब तक ब्लॉक किया जाता है जब तक म्यूटेक्स लॉक नहीं हो जाता है। वर्तमान में म्यूटेक्स को बंद कर दिया गया एक धागा फिर से उसी म्यूटेक्स को लॉक नहीं कर सकता है

mtx लॉक करने के लिए म्यूटेक्स का पॉइंटर है।

चेतावनी

यदि आप एमुलेटर थ्रेड में बंद म्यूटेक्स को छोड़ते हैं जब आप थ्रेड को अपने नियंत्रण से बाहर कर देते हैं, तो आप बहुत संभव है कि पूरे एमुलेटर को डेडलॉक कर देंगे ।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

char *erl_drv_mutex_name(ErlDrvMutex *mtx)

एक सूचक को म्यूटेक्स नाम पर लौटाता है।

mtx एक प्रारंभिक म्यूटेक्स का सूचक है।

ध्यान दें

यह फ़ंक्शन केवल डीबगिंग उद्देश्यों के लिए लक्षित है।

int erl_drv_mutex_trylock(ErlDrvMutex *mtx)

म्यूटेक्स को लॉक करने की कोशिश करता है। वर्तमान में म्यूटेक्स को बंद कर दिया गया एक धागा फिर से उसी म्यूटेक्स को लॉक करने का प्रयास नहीं कर सकता है

mtx लॉक करने की कोशिश करने के लिए एक म्यूटेक्स का पॉइंटर है।

रिटर्न 0 सफलता पर, नहीं तो EBUSY

चेतावनी

यदि आप एमुलेटर थ्रेड में बंद म्यूटेक्स को छोड़ते हैं जब आप थ्रेड को अपने नियंत्रण से बाहर कर देते हैं, तो आप बहुत संभव है कि पूरे एमुलेटर को डेडलॉक कर देंगे ।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_mutex_unlock(ErlDrvMutex *mtx)

एक म्यूटेक्स को अनलॉक करता है। वर्तमान में म्यूटेक्स को कॉलिंग थ्रेड द्वारा लॉक किया जाना चाहिए।

mtx अनलॉक करने के लिए म्यूटेक्स का सूचक है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

int erl_drv_output_term(ErlDrvTermData port, ErlDrvTermData* term, int n)

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

ध्यान दें

पैरामीटर port है नहीं एक साधारण बंदरगाह संभाल, लेकिन एक बंदरगाह हैंडल का उपयोग परिवर्तित driver_mk_port

पैरामीटर term की एक सरणी के लिए अंक ErlDrvTermData के साथ n तत्वों। इस सरणी में ड्राइवर शब्द प्रारूप में वर्णित शब्द हैं। हर पद में सरणी में 1-4 तत्व होते हैं। पहले शब्द में एक शब्द प्रकार है और फिर तर्क हैं। पैरामीटर port भेजने वाले पोर्ट को निर्दिष्ट करता है।

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

  • एक टपल को तत्वों की संख्या के साथ निर्दिष्ट किया जाना चाहिए। (तत्व इस ERL_DRV_TUPLE शब्द से पहले के हैं ।)

  • एक मानचित्र को कुंजी-मूल्य जोड़े की संख्या के साथ निर्दिष्ट किया जाना चाहिए N ERL_DRV_MAP इस क्रम में मुख्य-मूल्य जोड़े को पहले होना चाहिए key1,value1,key2,value2,...,keyN,valueN :। डुप्लिकेट कुंजियों की अनुमति नहीं है।

  • एक सूची को तत्वों की संख्या के साथ निर्दिष्ट किया जाना चाहिए, जिसमें पूंछ भी शामिल है, जो कि पिछली अवधि है ERL_DRV_LIST

ERL_DRV_STRING_CONS एक सूची में स्ट्रिंग में "स्प्लिस" करने के लिए विशेष शब्द का उपयोग किया जाता है, इस तरह निर्दिष्ट एक स्ट्रिंग अपने आप में एक सूची नहीं है, लेकिन तत्व आसपास की सूची के तत्व हैं।

Term type            Arguments
---------            ---------
ERL_DRV_NIL
ERL_DRV_ATOM         ErlDrvTermData atom (from driver_mk_atom(char *string))
ERL_DRV_INT          ErlDrvSInt integer
ERL_DRV_UINT         ErlDrvUInt integer
ERL_DRV_INT64        ErlDrvSInt64 *integer_ptr
ERL_DRV_UINT64       ErlDrvUInt64 *integer_ptr
ERL_DRV_PORT         ErlDrvTermData port (from driver_mk_port(ErlDrvPort port))
ERL_DRV_BINARY       ErlDrvBinary *bin, ErlDrvUInt len, ErlDrvUInt offset
ERL_DRV_BUF2BINARY   char *buf, ErlDrvUInt len
ERL_DRV_STRING       char *str, int len
ERL_DRV_TUPLE        int sz
ERL_DRV_LIST         int sz
ERL_DRV_PID          ErlDrvTermData pid (from driver_connected(ErlDrvPort port)
                     or driver_caller(ErlDrvPort port))
ERL_DRV_STRING_CONS  char *str, int len
ERL_DRV_FLOAT        double *dbl
ERL_DRV_EXT2TERM     char *buf, ErlDrvUInt len
ERL_DRV_MAP          int sz

अहस्ताक्षरित पूर्णांक डेटा प्रकार ErlDrvUInt और हस्ताक्षरित पूर्णांक डेटा प्रकार ErlDrvSInt 64-बिट रनटाइम सिस्टम पर 32 बिट्स और 32-बिट रनटाइम सिस्टम पर 32 बिट्स चौड़ा है। उन्हें ईआरटीएस 5.6 में पेश किया गया था और int ऊपर दी गई सूची में कुछ तर्क दिए गए थे।

अहस्ताक्षरित पूर्णांक डेटा प्रकार ErlDrvUInt64 और हस्ताक्षरित पूर्णांक डेटा प्रकार ErlDrvSInt64 हमेशा 64 बिट्स चौड़ा होता है। उन्हें ईआरटीएस 5.7.4 में पेश किया गया था।

टपल बनाने के लिए {tcp, Port, [100 | Binary]} , निम्नलिखित कॉल किया जा सकता है।

ErlDrvBinary* bin = ...
ErlDrvPort port = ...
ErlDrvTermData spec[] = {
    ERL_DRV_ATOM, driver_mk_atom("tcp"),
    ERL_DRV_PORT, driver_mk_port(drvport),
        ERL_DRV_INT, 100,
        ERL_DRV_BINARY, bin, 50, 0,
        ERL_DRV_LIST, 2,
    ERL_DRV_TUPLE, 3,
};
erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));    

यहां bin कम से कम 50 की लंबाई वाला एक ड्राइवर बाइनरी है और drvport एक पोर्ट हैंडल है। ERL_DRV_LIST सूची के तत्वों के बाद आने वाली सूचना , इसी तरह ERL_DRV_TUPLE

ERL_DRV_STRING_CONS अवधि श्रृंखला बनाते हैं करने के लिए एक तरीका है। यह अलग तरीके से ERL_DRV_STRING काम करता है कि कैसे काम करता है। ERL_DRV_STRING_CONS एक स्ट्रिंग सूची को उल्टे क्रम में बनाता है (कैसे ERL_DRV_LIST काम करता है के विपरीत ), सूची में जोड़े गए स्ट्रिंग को समेटना। पूंछ को पहले निर्दिष्ट किया जाना चाहिए ERL_DRV_STRING_CONS

ERL_DRV_STRING एक स्ट्रिंग का निर्माण करता है, और इसे समाप्त करता है। (तो यह ERL_DRV_NIL उसके बाद के रूप में ही है ERL_DRV_STRING_CONS ।)

/* to send [x, "abc", y] to the port: */
ErlDrvTermData spec[] = {
    ERL_DRV_ATOM, driver_mk_atom("x"),
    ERL_DRV_STRING, (ErlDrvTermData)"abc", 3,
    ERL_DRV_ATOM, driver_mk_atom("y"),
    ERL_DRV_NIL,
    ERL_DRV_LIST, 4
};
erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));    
/* to send "abc123" to the port: */
ErlDrvTermData spec[] = {
    ERL_DRV_NIL,        /* with STRING_CONS, the tail comes first */
    ERL_DRV_STRING_CONS, (ErlDrvTermData)"123", 3,
    ERL_DRV_STRING_CONS, (ErlDrvTermData)"abc", 3,
};
erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));    

ERL_DRV_EXT2TERM अवधि प्रकार एक शब्द के साथ इनकोडिंग पारित करने के लिए प्रयोग किया जाता है external format , एक शब्द है कि द्वारा कूटबद्ध किया गया है, वह है erlang:term_to_binary , erl_interface:ei(3) , और इतने पर। उदाहरण के लिए, यदि binp कोई पॉइंटर है, ErlDrvBinary जिसमें शब्द {17, 4711} इनकोडेड है external format , और आप इसे टैग के साथ टू-टपल में लपेटना चाहते हैं my_tag , अर्थात {my_tag, {17, 4711}} , आप निम्नानुसार कर सकते हैं:

ErlDrvTermData spec[] = {
        ERL_DRV_ATOM, driver_mk_atom("my_tag"),
        ERL_DRV_EXT2TERM, (ErlDrvTermData) binp->orig_bytes, binp->orig_size
    ERL_DRV_TUPLE, 2,
};
erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));    

नक्शा बनाने के लिए #{key1 => 100, key2 => {200, 300}} , निम्नलिखित कॉल किया जा सकता है।

ErlDrvPort port = ...
ErlDrvTermData spec[] = {
    ERL_DRV_ATOM, driver_mk_atom("key1"),
        ERL_DRV_INT, 100,
    ERL_DRV_ATOM, driver_mk_atom("key2"),
        ERL_DRV_INT, 200,
        ERL_DRV_INT, 300,
    ERL_DRV_TUPLE, 2,
    ERL_DRV_MAP, 2
};
erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));    

आप एक द्विआधारी पास करना चाहते हैं और पहले से ही एक में द्विआधारी की सामग्री नहीं है, तो ErlDrvBinary , आप का उपयोग कर से लाभ उठा सकते ERL_DRV_BUF2BINARY बजाय एक बनाने ErlDrvBinary के माध्यम से driver_alloc_binary और फिर के माध्यम से बाइनरी पारित ERL_DRV_BINARY । रनटाइम सिस्टम अक्सर ERL_DRV_BUF2BINARY इस्तेमाल होने पर बायनेरी होशियार को आवंटित करता है। हालांकि, यदि बाइनरी की सामग्री पहले से ही पास में रहती है ErlDrvBinary , तो सामान्य रूप से ERL_DRV_BINARY और ErlDrvBinary प्रश्न में बाइनरी का उपयोग करना बेहतर होता है ।

ERL_DRV_UINT , ERL_DRV_BUF2BINARY , और ERL_DRV_EXT2TERM अवधि प्रकार ERTS 5.6 में पेश किए गए।

यह फ़ंक्शन केवल थ्रेड-सुरक्षित है जब एसएमपी समर्थन वाले एमुलेटर का उपयोग किया जाता है।

int erl_drv_putenv(const char *key, char *value)

एक पर्यावरण चर का मान सेट करता है।

key एक NULL पर्यावरण स्ट्रिंग के नाम से युक्त स्ट्रिंग है।

value एक है NULL -terminated स्ट्रिंग वातावरण चर के नए मूल्य से युक्त।

रिटर्न 0 सफलता पर, अन्यथा एक मूल्य != 0

ध्यान दें

"" मान के रूप में रिक्त स्ट्रिंग ( ) को पारित करने का परिणाम प्लेटफ़ॉर्म-निर्भर है। कुछ प्लेटफ़ॉर्म पर वैरिएबल मान को रिक्त स्ट्रिंग पर सेट किया जाता है, दूसरों पर पर्यावरण चर हटा दिया जाता है।

चेतावनी

यह फ़ंक्शन उपयोग किए गए उत्सर्जित वातावरण को संशोधित करता है os:putenv/2 और libc putenv(3) या समान द्वारा उपयोग किए जाने वाले वातावरण को नहीं । जिन ड्राइवरों को आवश्यकता है कि ये सिंक में हैं उन्हें स्वयं ऐसा करने की आवश्यकता होगी, लेकिन ध्यान रखें कि उन्हें एक कारण के लिए अलग किया गया है; putenv(3) और इसके दोस्त थ्रेड-सुरक्षित नहीं हैं और एमुलेटर को दुर्व्यवहार या क्रैश करने के लिए असंबंधित कोड हो सकते हैं।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

ErlDrvRWLock *erl_drv_rwlock_create(char *name)

एक rwlock बनाता है और उसे एक पॉइंटर लौटाता है।

name एक स्ट्रिंग निर्मित rwlock की पहचान है। इसका उपयोग नियोजित भविष्य डिबग कार्यक्षमता में rwlock की पहचान करने के लिए किया जाता है।

NULL असफलता पर लौटाता है। चालक को उतारने से पहले इसे नष्ट करने के लिए rwlock बनाने वाला ड्राइवर जिम्मेदार है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_rwlock_destroy(ErlDrvRWLock *rwlck)

पहले से बनाए गए एक झुंड को नष्ट कर देता है erl_drv_rwlock_create । नष्ट होने से पहले rwlock एक अनलॉक स्थिति में होना चाहिए।

rwlck नष्ट करने के लिए एक rwlock के लिए एक सूचक है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

char *erl_drv_rwlock_name(ErlDrvRWLock *rwlck)

एक संकेतक को rwlock के नाम पर लौटाता है।

rwlck इनिशियलाइज़ेड आरवलॉक का पॉइंटर है।

ध्यान दें

यह फ़ंक्शन केवल डीबगिंग उद्देश्यों के लिए लक्षित है।

void erl_drv_rwlock_rlock(ErlDrvRWLock *rwlck)

एक ताला खोलो पढ़ें। कॉलिंग थ्रेड को तब तक ब्लॉक किया जाता है जब तक कि आरलॉक को लॉक नहीं किया गया है। एक थ्रेड जिसे वर्तमान में पढ़ा या पढ़ा / लॉक किया गया है, उसे फिर से उसी rlock को लॉक नहीं किया जा सकता है

rwlck ताला पढ़ने के लिए rwlock के लिए एक सूचक है।

चेतावनी

यदि आप एक एमुलेटर थ्रेड में लॉक किए गए एक rwlock को छोड़ते हैं जब आप थ्रेड को अपने नियंत्रण से बाहर कर देते हैं, तो आप बहुत संभव है कि पूरे एमुलेटर को डेडलॉक कर देंगे ।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_rwlock_runlock(ErlDrvRWLock *rwlck)

एक अनलॉक अनलॉक पढ़ें। Rwlock वर्तमान में कॉलिंग थ्रेड द्वारा लॉक पढ़ा जाना चाहिए।

rwlck अनलॉक पढ़ने के लिए rwlock के लिए एक सूचक है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_rwlock_rwlock(ErlDrvRWLock *rwlck)

पढ़ें / एक ताला ताले लिखते हैं। कॉल थ्रेड को तब तक ब्लॉक किया जाता है जब तक कि rwlock को लॉक / रीड / राइट न कर दिया गया हो। एक थ्रेड जिसे वर्तमान में पढ़ा या पढ़ा / लॉक किया गया है, उसे फिर से उसी rlock को लॉक नहीं किया जा सकता है

rwlck ताला पढ़ने / लिखने के लिए rwlock के लिए एक संकेतक है।

चेतावनी

यदि आप एक एमुलेटर थ्रेड में लॉक किए गए एक rwlock को छोड़ते हैं जब आप थ्रेड को अपने नियंत्रण से बाहर कर देते हैं, तो आप बहुत संभव है कि पूरे एमुलेटर को डेडलॉक कर देंगे ।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_rwlock_rwunlock(ErlDrvRWLock *rwlck)

पढ़ें / एक अनलॉक अनलॉक लिखता है। वर्तमान में कॉलिंग थ्रेड द्वारा लॉक किए गए rwlock को पढ़ना / लिखना होगा।

rwlck अनलॉक पढ़ने / लिखने के लिए rwlock के लिए एक सूचक है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

int erl_drv_rwlock_tryrlock(ErlDrvRWLock *rwlck)

एक ताला खोलने के लिए पढ़ने की कोशिश करता है।

rwlck ताला खोलने के लिए प्रयास करने के लिए एक rwlock के लिए एक सूचक है।

रिटर्न 0 सफलता पर, नहीं तो EBUSY । एक थ्रेड जिसे वर्तमान में पढ़ा या पढ़ा / लॉक किया गया है, उसे फिर से उसी rwlock को लॉक करने का प्रयास नहीं किया जा सकता है

चेतावनी

यदि आप एक एमुलेटर थ्रेड में लॉक किए गए एक rwlock को छोड़ते हैं जब आप थ्रेड को अपने नियंत्रण से बाहर कर देते हैं, तो आप बहुत संभव है कि पूरे एमुलेटर को डेडलॉक कर देंगे ।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

int erl_drv_rwlock_tryrwlock(ErlDrvRWLock *rwlck)

एक ताला खोलने के लिए पढ़ने / लिखने की कोशिश करता है। एक थ्रेड जिसे वर्तमान में पढ़ा या पढ़ा / लॉक किया गया है, उसे फिर से उसी rwlock को लॉक करने का प्रयास नहीं किया जा सकता है

rwlck ताला पढ़ने / लिखने की कोशिश करने के लिए एक rwlock के लिए सूचक है।

रिटर्न 0 सफलता पर, नहीं तो EBUSY

चेतावनी

यदि आप एक एमुलेटर थ्रेड में लॉक किए गए एक rwlock को छोड़ते हैं जब आप थ्रेड को अपने नियंत्रण से बाहर कर देते हैं, तो आप बहुत संभव है कि पूरे एमुलेटर को डेडलॉक कर देंगे ।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

int erl_drv_send_term(ErlDrvTermData port, ErlDrvTermData receiver, ErlDrvTermData* term, int n)

यह फ़ंक्शन पोर्ट स्वामी प्रक्रिया की तुलना में ड्राइवर को अन्य प्रक्रियाओं में डेटा भेजने का एकमात्र तरीका है। पैरामीटर receiver डेटा प्राप्त करने के लिए प्रक्रिया को निर्दिष्ट करता है।

ध्यान दें

पैरामीटर port है नहीं एक साधारण बंदरगाह संभाल, लेकिन एक बंदरगाह हैंडल का उपयोग परिवर्तित driver_mk_port

पैरामीटर port , term और में n काम करते हैं erl_drv_output_term

यह फ़ंक्शन केवल थ्रेड-सुरक्षित है जब एसएमपी समर्थन वाले एमुलेटर का उपयोग किया जाता है।

void erl_drv_set_os_pid(ErlDrvPort port, ErlDrvSInt pid)

इस पोर्ट पर os_pid करते समय देखा गया सेट करता है erlang:port_info/2

port पोर्ट सेट करने के लिए पोर्ट (ड्राइवर उदाहरण) का पोर्ट हैंडल है। pid सेट करने के लिए pid है।

int erl_drv_thread_create(char *name, ErlDrvTid *tid, void * (*func)(void *), void *arg, ErlDrvThreadOpts *opts)

एक नया सूत्र रचता है।

name
निर्मित धागे की पहचान करने वाली एक स्ट्रिंग। इसका उपयोग योजनाबद्ध भविष्य डिबग कार्यक्षमता में धागे की पहचान करने के लिए किया जाता है।
tid
थ्रेड पहचानकर्ता चर के लिए एक सूचक।
func
फ़ंक्शन के लिए एक संकेतक बनाया थ्रेड में निष्पादित करने के लिए।
arg
func फ़ंक्शन के लिए तर्क देने के लिए एक सूचक ।
opts
उपयोग करने या करने के लिए थ्रेड विकल्पों के लिए एक सूचक NULL

रिटर्न 0 सफलता पर, अन्यथा एक errno मूल्य त्रुटि इंगित करने के लिए दिया जाता है। नव निर्मित थ्रेड द्वारा इंगित फ़ंक्शन में निष्पादित करना शुरू कर देता है func , और तर्क के रूप func में पारित किया arg जाता है। जब erl_drv_thread_create लौटता है, तो नए बनाए गए थ्रेड के थ्रेड आइडेंटिफायर में उपलब्ध होता है *tid opts या तो एक NULL पॉइंटर हो सकता है , या एक ErlDrvThreadOpts स्ट्रक्चर के लिए एक पॉइंटर । यदि opts कोई NULL सूचक है, तो डिफ़ॉल्ट विकल्प का उपयोग किया जाता है, अन्यथा पारित विकल्प का उपयोग किया जाता है।

चेतावनी

आपको ErlDrvThreadOpts संरचना को अपने आप से आवंटित करने की अनुमति नहीं है । इसे आबंटित और आरंभ किया जाना चाहिए erl_drv_thread_opts_create

निर्मित थ्रेड या तो समाप्त होता है जब func रिटर्न या यदि erl_drv_thread_exit थ्रेड द्वारा कहा जाता है। थ्रेड का निकास मान या तो से लौटा है func या तर्क के रूप में पारित किया गया है erl_drv_thread_exit । थ्रेड बनाने वाला ड्रायवर थ्रेड से जुड़ने के लिए ज़िम्मेदार है erl_drv_thread_join , इससे पहले कि ड्राइवर अनलोड हो। "अलग किए गए" धागे बनाए नहीं जा सकते हैं, अर्थात, ऐसे धागे जिन्हें शामिल होने की आवश्यकता नहीं है।

चेतावनी

लोड किए जाने से पहले सभी बनाए गए थ्रेड्स को ड्राइवर द्वारा शामिल किया जाना चाहिए। यदि ड्राइवर अनलोड किए जाने से पहले बनाए गए सभी थ्रेड्स में शामिल होने में विफल रहता है, तो ड्राइवर कोड अनलोड किए जाने पर रनटाइम सिस्टम सबसे अधिक संभावित क्रैश हो जाता है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_thread_exit(void *exit_value)

एग्ज़िट वैल्यू के साथ कॉलिंग थ्रेड को तर्क के रूप में समाप्त करता है। exit_value निकास मान के लिए एक सूचक है या NULL

आपको केवल बनाए गए थ्रेड को समाप्त करने की अनुमति है erl_drv_thread_create

निकास मान बाद में किसी अन्य थ्रेड द्वारा प्राप्त किया जा सकता है erl_drv_thread_join

यह फ़ंक्शन थ्रेड-सुरक्षित है।

int erl_drv_thread_join(ErlDrvTid tid, void **exit_value)

कॉलिंग थ्रेड को किसी अन्य थ्रेड के साथ जोड़ता है, अर्थात, कॉलिंग थ्रेड को तब तक ब्लॉक किया जाता है जब तक कि थ्रेड की पहचान tid समाप्त नहीं हो जाती।

tid शामिल होने के लिए धागे की पहचानकर्ता है। exit_value एक पॉइंटर को पॉइंटर से एग्जिट वैल्यू तक, या NULL

रिटर्न 0 सफलता पर, अन्यथा एक errno मूल्य त्रुटि इंगित करने के लिए दिया जाता है।

एक धागा केवल एक बार जुड़ सकता है। एक से अधिक बार शामिल होने का व्यवहार अपरिभाषित है, एक एमुलेटर दुर्घटना की संभावना है। यदि exit_value == NULL , समाप्त किए गए धागे के निकास मूल्य को नजरअंदाज कर दिया जाता है, अन्यथा समाप्त धागे के निकास मूल्य को संग्रहीत किया जाता है *exit_value

यह फ़ंक्शन थ्रेड-सुरक्षित है।

char *erl_drv_thread_name(ErlDrvTid tid)

धागे के नाम पर एक सूचक लौटाता है।

tid एक धागा पहचानकर्ता है।

ध्यान दें

यह फ़ंक्शन केवल डीबगिंग उद्देश्यों के लिए लक्षित है।

ErlDrvThreadOpts *erl_drv_thread_opts_create(char *name)

एक थ्रेड विकल्प संरचना को आवंटित और आरंभ करता है।

name निर्मित थ्रेड विकल्पों की पहचान करने वाला एक स्ट्रिंग है। इसका उपयोग नियोजित भविष्य डिबग कार्यक्षमता में थ्रेड विकल्पों की पहचान करने के लिए किया जाता है।

NULL असफलता पर लौटाता है। पास करने के विकल्पों के लिए एक थ्रेड विकल्प संरचना का उपयोग किया जाता है erl_drv_thread_create । यदि संरचना को पास करने से पहले संशोधित नहीं किया जाता है erl_drv_thread_create , तो डिफ़ॉल्ट मानों का उपयोग किया जाता है।

चेतावनी

आपको ErlDrvThreadOpts संरचना को अपने आप से आवंटित करने की अनुमति नहीं है । इसे आबंटित और आरंभ किया जाना चाहिए erl_drv_thread_opts_create

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_thread_opts_destroy(ErlDrvThreadOpts *opts)

पहले से बनाए गए थ्रेड विकल्पों को नष्ट कर देता है erl_drv_thread_opts_create

opts नष्ट करने के लिए थ्रेड विकल्पों के लिए एक सूचक है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

ErlDrvTid erl_drv_thread_self(void)

कॉलिंग थ्रेड के थ्रेड पहचानकर्ता देता है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

ErlDrvTime erl_drv_time_offset(ErlDrvTimeUnit time_unit)

वर्तमान समय को बीच में ऑफसेट करता है Erlang monotonic time और तर्क के रूप Erlang system time में परिवर्तित time_unit हो जाता है।

time_unit लौटाए गए मूल्य की समय इकाई है।

ERL_DRV_TIME_ERROR यदि कोई अमान्य समय इकाई तर्क के साथ कहा जाता है, या यदि वह थ्रेड से कॉल किया जाता है, जो कोई शेड्यूलर थ्रेड नहीं है, तो लौटाता है

यह भी देखें ErlDrvTime और ErlDrvTimeUnit

void *erl_drv_tsd_get(ErlDrvTSDKey key)

key कॉलिंग थ्रेड के लिए संबंधित थ्रेड-विशिष्ट डेटा देता है ।

key एक थ्रेड-विशिष्ट डेटा कुंजी है।

कॉलिंग थ्रेड के लिए NULL कोई डेटा संबद्ध नहीं होने पर वापस लौटाता है key

यह फ़ंक्शन थ्रेड-सुरक्षित है।

int erl_drv_tsd_key_create(char *name, ErlDrvTSDKey *key)

एक थ्रेड-विशिष्ट डेटा कुंजी बनाता है।

name निर्मित कुंजी की पहचान करने वाला एक स्ट्रिंग है। इसका उपयोग नियोजित भविष्य डिबग कार्यक्षमता में कुंजी की पहचान करने के लिए किया जाता है।

key एक थ्रेड-विशिष्ट डेटा कुंजी चर के लिए एक सूचक है।

रिटर्न 0 सफलता पर, अन्यथा एक errno मूल्य त्रुटि इंगित करने के लिए दिया जाता है। कुंजी बनाने वाला ड्राइवर चालक को उतारने से पहले उसे नष्ट करने के लिए जिम्मेदार होता है।

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_tsd_key_destroy(ErlDrvTSDKey key)

पहले से बनाई गई एक थ्रेड-विशिष्ट डेटा कुंजी को नष्ट कर देता है erl_drv_tsd_key_create । सभी थ्रेड्स में इस कुंजी का उपयोग करने वाले सभी थ्रेड-विशिष्ट डेटा erl_drv_tsd_set को कॉल करने से पहले साफ़ (देखें ) करना होगा erl_drv_tsd_key_destroy

key नष्ट करने के लिए एक थ्रेड-विशिष्ट डेटा कुंजी है।

चेतावनी

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

यह फ़ंक्शन थ्रेड-सुरक्षित है।

void erl_drv_tsd_set(ErlDrvTSDKey key, void *data)

key कॉलिंग थ्रेड के लिए संबंधित थ्रेड-विशिष्ट डेटा सेट करता है । आपको केवल थ्रेड के लिए थ्रेड-विशिष्ट डेटा सेट करने की अनुमति है, जबकि वे पूरी तरह से आपके नियंत्रण में हैं। उदाहरण के लिए, यदि आप ड्राइवर कॉलबैक फ़ंक्शन को थ्रेडिंग में थ्रेड-विशिष्ट डेटा सेट करते हैं, तो इसे ड्राइवर कॉलबैक फ़ंक्शन NULL से लौटने से पहले , इसे साफ़ करना होगा ।

key एक थ्रेड-विशिष्ट डेटा कुंजी है।

data key कॉलिंग थ्रेड में संबद्ध करने के लिए डेटा का एक पॉइंटर है ।

चेतावनी

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

यह फ़ंक्शन थ्रेड-सुरक्षित है।

char *erl_errno_id(int error)

त्रुटि संख्या दिए जाने पर, एरलांग त्रुटि का परमाणु नाम लौटाता है error । त्रुटि परमाणुओं हैं einval , enoent , और इतने पर। इसका उपयोग ड्राइवर से त्रुटि शब्द बनाने के लिए किया जा सकता है।

int remove_driver_entry(ErlDrvEntry *de)

de पहले से जोड़ा गया ड्राइवर प्रविष्टि निकालता है add_driver_entry

erl_ddll Erlang इंटरफ़ेस द्वारा जोड़ी गई ड्राइवर प्रविष्टियों को इस इंटरफ़ेस का उपयोग करके हटाया नहीं जा सकता है।

void set_busy_port(ErlDrvPort port, int on)

सेट और पोर्ट की व्यस्त स्थिति को अनसेट करता है। यदि on गैर-शून्य है, तो पोर्ट व्यस्त में सेट है। यदि यह शून्य है, तो पोर्ट व्यस्त नहीं है पर सेट है। आप आमतौर पर इस सुविधा को busy port message queue कार्यक्षमता के साथ जोड़ना चाहते हैं ।

यदि पोर्ट या पोर्ट संदेश कतार व्यस्त है, तो पोर्ट पर कमांड डेटा भेजने वाली प्रक्रियाएं निलंबित हैं। जब पोर्ट या पोर्ट संदेश कतार व्यस्त नहीं है, तो निलंबित प्रक्रियाएँ फिर से शुरू हो जाती हैं। कमांड डेटा इस संदर्भ में Port ! {Owner, {command, Data}} या तो या पोर्ट का उपयोग कर पोर्ट के लिए पारित डेटा है port_command/[2,3]

यदि डेटा driver_flags में सेट किया गया है driver_entry , तो डेटा को ड्राइवर के माध्यम से मजबूर किया जा सकता है, erlang:port_command(Port, Data, [force]) भले ही चालक ने संकेत दिया हो कि यह व्यस्त है।

व्यस्त पोर्ट संदेश कतार कार्यक्षमता के बारे में जानकारी के लिए, देखें erl_drv_busy_msgq_limits

void set_port_control_flags(ErlDrvPort port, int flags)

control ड्राइवर एंट्री फ़ंक्शन पोर्ट स्वामी प्रक्रिया में डेटा कैसे लौटाएगा , इसके लिए झंडे सेट करता है। ( control फ़ंक्शन कहा जाता है erlang:port_control/3 ।)

वर्तमान में इसके लिए केवल दो सार्थक मूल्य हैं flags : 0 इसका मतलब है कि डेटा को किसी सूची में लौटाया जाता है, और PORT_CONTROL_FLAG_BINARY इसका अर्थ है कि डेटा को बाइनरी के रूप में वापस किया जाता है control

यह भी देखें

driver_entry , erlang(3) , erl_ddll(3) , खंड How to Implement an Alternative Carrier for the Erlang Distribution उपयोगकर्ता मार्गदर्शिका में

Original text