void add_driver_entry(ErlDrvEntry *de)

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

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 है।

unsigned int driver_async_port_key(ErlDrvPort port)

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

long driver_binary_dec_refc(ErlDrvBinary *bin)

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

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

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 ।

सफलता पर एक नया निर्मित पोर्ट डेटा लॉक लौटाता है, अन्यथा 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 ।

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

वापसी मूल्य 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 प्रतीक्षा करते समय अनलॉक करने के लिए एक म्यूटेक्स का सूचक है।

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

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 यदि वे समान हैं तो एक मूल्य नहीं ।

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

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 उसे आवश्यक बफ़र आकार में सेट कर दिया जाता है।

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

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 कार्यों स्थानीय नोड पर किसी भी प्रक्रिया के लिए भेजने के लिए इस्तेमाल किया जा सकता है।

पैरामीटर 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 ।

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

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 के लिए एक सूचक है।

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

void erl_drv_rwlock_runlock(ErlDrvRWLock *rwlck)

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

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

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

void erl_drv_rwlock_rwlock(ErlDrvRWLock *rwlck)

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

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

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

void erl_drv_rwlock_rwunlock(ErlDrvRWLock *rwlck)

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

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

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

int erl_drv_rwlock_tryrlock(ErlDrvRWLock *rwlck)

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

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

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

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

int erl_drv_rwlock_tryrwlock(ErlDrvRWLock *rwlck)

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

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

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

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

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

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

पैरामीटर 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 , तो डिफ़ॉल्ट मानों का उपयोग किया जाता है।

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

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 ।