एरलैंग चालक एक पुस्तकालय है जिसमें देशी ड्राइवर कॉलबैक फ़ंक्शन का एक सेट होता है जो कुछ घटनाओं के होने पर एर्लैंग वर्चुअल मशीन कॉल करता है।
ड्राइवर के कई उदाहरण हो सकते हैं, प्रत्येक उदाहरण एक Erlang पोर्ट के साथ जुड़ा हुआ है।
प्रत्येक ड्राइवर का उदाहरण एक पोर्ट के साथ जुड़ा हुआ है।
प्रत्येक पोर्ट में एक पोर्ट स्वामी प्रक्रिया होती है।
पोर्ट के साथ संचार आमतौर पर पोर्ट मालिक प्रक्रिया के माध्यम से किया जाता है।
अधिकांश फ़ंक्शन एक तर्क के रूप में
port
हैंडल लेते हैं।
यह ड्राइवर के उदाहरण की पहचान करता है।
ध्यान दें कि इस पोर्ट हैंडल को चालक द्वारा संग्रहित किया जाना चाहिए, यह तब नहीं दिया जाता है जब चालक को एमुलेटर से बुलाया जाता है (
driver_entry
देखें)।
SMP समर्थन के साथ रनटाइम सिस्टम में, ड्राइवर को ड्राइवर स्तर या पोर्ट स्तर (ड्राइवर आवृत्ति स्तर) पर लॉक किया जाता है।
डिफ़ॉल्ट रूप से ड्राइवर स्तर लॉकिंग का उपयोग किया जाएगा, अर्थात, एक समय में केवल एक एम्यूलेटर थ्रेड ड्राइवर में कोड निष्पादित करेगा।
यदि पोर्ट स्तर लॉकिंग का उपयोग किया जाता है, तो एक ही समय में कई एम्यूलेटर थ्रेड ड्राइवर में कोड निष्पादित कर सकते हैं।
हालांकि, एक बार में केवल एक धागा उसी पोर्ट के लिए ड्राइवर कॉलबैक कॉल करेगा, हालांकि।
पोर्ट स्तर लॉकिंग को सक्षम करने के लिए,
driver_flags
द्वारा उपयोग किए गए
driver_entry
में
ERL_DRV_FLAG_USE_PORT_LOCKING
driver_flags
सेट करें।
जब पोर्ट स्तर लॉकिंग का उपयोग किया जाता है, तो ड्राइवर लेखक पोर्ट (ड्राइवर इंस्टेंस) द्वारा साझा किए गए डेटा तक सभी एक्सेस को सिंक्रनाइज़ करने के लिए जिम्मेदार होता है।
ड्राइवर स्तर लॉकिंग का उपयोग किया जाता है, तो SMP समर्थन के साथ रनटाइम सिस्टम से पहले लिखे गए अधिकांश ड्राइवर SMP समर्थन के साथ रनटाइम सिस्टम में चल सकते हैं।
इससे पहले, SMP सपोर्ट के बिना रनटाइम सिस्टम में, विशिष्ट ड्राइवर कॉलबैक को हमेशा एक ही थ्रेड से बुलाया जाता था।
SMP समर्थन के साथ रनटाइम सिस्टम में ऐसा
नहीं
है।
लॉकिंग योजना का उपयोग करने के बावजूद, ड्राइवर कॉलबैक के लिए कॉल विभिन्न थ्रेड्स से किए जा सकते हैं।
उदाहरण के लिए, ठीक उसी पोर्ट के लिए एक ही कॉलबैक के लिए दो लगातार कॉल दो अलग-अलग थ्रेड से किए जा सकते हैं।
यह
ज्यादातर
ड्राइवरों के लिए समस्या नहीं है, लेकिन यह हो सकता है।
ड्राइवर जो सभी कॉलबैक पर निर्भर करते हैं जिन्हें एक ही थ्रेड में कहा जाता है, उन्हें SMP समर्थन के साथ रनटाइम सिस्टम में उपयोग करने से पहले फिर से लिखना
होगा
।
सभी कार्य जो ड्राइवर को एर्लांग के साथ करने की आवश्यकता होती है, ड्राइवर एपीआई कार्यों के माध्यम से किए जाते हैं।
निम्नलिखित कार्यक्षमता के लिए कार्य मौजूद हैं:
एक ड्राइवर और केवल recompile को अपडेट नहीं करने के लिए, यह संभवतया तब काम करता है जब 32-बिट मशीन के लिए निर्माण सुरक्षा की झूठी भावना पैदा करता है।
उम्मीद है कि कई महत्वपूर्ण चेतावनी उत्पन्न करेगा।
लेकिन जब एक ही ड्राइवर को 64-बिट मशीन के लिए बाद में पुनः स्थापित किया जाता है, तो चेतावनी और लगभग निश्चित रूप से क्रैश हो जाएगा।
इसलिए ड्राइवर को अपडेट करना और चेतावनी को ठीक नहीं करना एक
बुरा
विचार है।
निम्नलिखित एक पूर्व ERTS 5.9 ड्राइवर के पुनर्लेखन के लिए एक चेकलिस्ट है, जो सबसे महत्वपूर्ण है:
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)
पैरामीटर द्वारा बताई गई मेमोरी में टाइम स्टैम्प पढ़ता है
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)
पैरामीटर
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)
ध्यान दें
इस फ़ंक्शन के मापदंडों को रनटाइम सिस्टम द्वारा ठीक से जांच नहीं किया जा सकता है जब मनमाने धागे द्वारा निष्पादित किया जाता है।
यह फ़ंक्शन को तब विफल करने का कारण बन सकता है जब इसे करना चाहिए।
पैरामीटर
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
सूचक है, तो डिफ़ॉल्ट विकल्प का उपयोग किया जाता है, अन्यथा पारित विकल्प का उपयोग किया जाता है।
निर्मित थ्रेड या तो समाप्त होता है जब
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
।