Erlang 21

erl_nif




erlang

erl_nif

C लाइब्रेरी

erl_nif

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

एपीआई एक एरलांग एनआईएफ लाइब्रेरी के लिए कार्य करता है।

विवरण

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

चेतावनी

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

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

  • एक मूल फ़ंक्शन जो क्रैश पूरे VM को क्रैश करेगा।

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

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

एनआईएफ पुस्तकालय का एक न्यूनतम उदाहरण निम्नानुसार देखा जा सकता है:

/* niftest.c */
#include <erl_nif.h>

static ERL_NIF_TERM hello(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    return enif_make_string(env, "Hello world!", ERL_NIF_LATIN1);
}

static ErlNifFunc nif_funcs[] =
{
    {"hello", 0, hello}
};

ERL_NIF_INIT(niftest,nif_funcs,NULL,NULL,NULL,NULL)

Erlang मॉड्यूल निम्नानुसार देख सकते हैं:

-module(niftest).

-export([init/0, hello/0]).

init() ->
      erlang:load_nif("./niftest", 0).

hello() ->
      "NIF library not loaded".

संकलन और परीक्षण निम्नानुसार (लिनक्स पर) देख सकते हैं:

$> gcc -fPIC -shared -o niftest.so niftest.c -I $ERL_ROOT/usr/include/
$> erl

1> c(niftest).
{ok,niftest}
2> niftest:hello().
"NIF library not loaded"
3> niftest:init().
ok
4> niftest:hello().
"Hello world!"

एक वास्तविक मॉड्यूल के लिए एक बेहतर समाधान नए निर्देश on_load का लाभ on_load (देखें कि अनुभाग Running a Function When a Module is Loaded लोड होने पर NIF लाइब्रेरी को स्वचालित रूप से लोड करने के लिए Erlang संदर्भ मैनुअल में Running a Function When a Module is Loaded किया जाता है)।

ध्यान दें

एक NIF को निर्यात नहीं करना पड़ता है, यह मॉड्यूल के लिए स्थानीय हो सकता है। हालांकि, अप्रयुक्त स्थानीय ठूंठ कार्यों को संकलक द्वारा दूर किया जाएगा, जिससे एनआईएफ पुस्तकालय की लोडिंग विफल हो जाएगी।

एक बार लोड होने के बाद, एक NIF लाइब्रेरी लगातार बनी रहती है। यह तब तक अनलोड नहीं किया जाएगा जब तक कि मॉड्यूल कोड संस्करण जो कि शुद्ध न हो।

कार्यक्षमता

NIF कोड और Erlang रनटाइम सिस्टम के बीच सभी इंटरैक्शन NIF API फ़ंक्शन को कॉल करके किया जाता है। निम्नलिखित कार्यक्षमता के लिए कार्य मौजूद हैं:

एरलांग शब्द पढ़ें और लिखें

किसी भी एर्लैंग की शर्तों को फ़ंक्शन तर्क के रूप में एनआईएफ को पारित किया जा सकता है और फ़ंक्शन रिटर्न मान के रूप में लौटाया जा सकता है। ये शब्द C- टाइप ERL_NIF_TERM और ERL_NIF_TERM केवल API फ़ंक्शन का उपयोग करके पढ़ा या लिखा जा सकता है। किसी पद की सामग्री को पढ़ने के लिए अधिकांश कार्य पहले से enif_get_ किए जाते हैं enif_get_ और आमतौर पर true (या false ) वापस आते हैं यदि शब्द अपेक्षित प्रकार (या नहीं) है। शब्द लिखने के कार्य सभी उपसर्ग enif_make_ और आमतौर पर बनाए गए ERL_NIF_TERM वापस करते हैं। कुछ शर्तों को क्वेरी करने के लिए भी हैं, जैसे कि enif_is_atom , enif_is_identical और enif_compare

ERL_NIF_TERM प्रकार की सभी शर्तें ERL_NIF_TERM प्रकार के वातावरण से संबंधित हैं। एक शब्द का जीवनकाल अपने पर्यावरण वस्तु के जीवनकाल द्वारा नियंत्रित होता है। सभी API फ़ंक्शंस जो पढ़ने या लिखने की शर्तों में पर्यावरण है कि यह शब्द पहले फ़ंक्शन तर्क के रूप में है।

बाइनरी

प्रकार के बाइनरी की शर्तों को स्ट्रक्चर प्रकार की मदद से एक्सेस किया जाता है ErlNifBinary , जिसमें ErlNifBinary के कच्चे बाइनरी डेटा और डेटा की लंबाई ( size ) में एक सूचक ( data ) होता है। data और size दोनों ही केवल पढ़ने के लिए हैं और केवल API फ़ंक्शन के लिए कॉल का उपयोग करके लिखे जाने हैं। हालाँकि, ErlNifBinary उदाहरण हमेशा उपयोगकर्ता द्वारा आवंटित किए जाते हैं (आमतौर पर स्थानीय चर के रूप में)।

डेटा द्वारा इंगित किया गया कच्चा डेटा केवल कॉल करने के बाद ही enif_alloc_binary या enif_realloc_binary कॉल करने enif_realloc_binary । बाइनरी पर काम करने वाले अन्य सभी कार्य डेटा को केवल पढ़ने के लिए छोड़ देते हैं। एक उत्परिवर्ती बाइनरी को अंत में या तो enif_release_binary साथ मुक्त किया जाना चाहिए या इसे केवल enif_make_binary साथ एक Erlang पद पर स्थानांतरित करके पढ़ा जाना चाहिए। हालाँकि, यह उसी NIF कॉल में नहीं होता है। पढ़ें-केवल बायनेरिज़ को जारी करने की आवश्यकता नहीं है

enif_make_new_binary को enif_make_new_binary कॉल में बाइनरी को आवंटित करने और वापस करने के लिए शॉर्टकट के रूप में उपयोग किया जा सकता है।

बायनेरिज़ पूरे बाइट्स के अनुक्रम हैं। मनमानी बिट की लंबाई के साथ बिटस्ट्रिंग्स का अभी तक कोई समर्थन नहीं है।

संसाधन वस्तुओं

संसाधन वस्तुओं का उपयोग एनआईएफ से देशी डेटा संरचनाओं को संकेत वापस करने का एक सुरक्षित तरीका है। एक संसाधन ऑब्जेक्ट केवल enif_alloc_resource साथ आवंटित मेमोरी का एक ब्लॉक है। इस मेमोरी ब्लॉक में एक हैंडल ("सुरक्षित पॉइंटर") को enif_make_resource के उपयोग द्वारा enif_make_resource लौटाया जा सकता है। enif_make_resource द्वारा लौटाया गया शब्द प्रकृति में अपारदर्शी है। इसे संग्रहीत किया जा सकता है और प्रक्रियाओं के बीच पारित किया जा सकता है, लेकिन एकमात्र वास्तविक उपयोग इसे एनआईएफ के तर्क के रूप में वापस पारित करना है। enif_get_resource तब enif_get_resource कॉल कर सकता है और मेमोरी ब्लॉक में एक पॉइंटर वापस प्राप्त कर सकता है, जो अभी भी मान्य होने की गारंटी है। जब तक अंतिम हैंडल शब्द VM द्वारा एकत्रित कचरा नहीं है और संसाधन को enif_release_resource (उस क्रम में जरूरी नहीं) के साथ जारी किया जाता है, तब तक एक संसाधन ऑब्जेक्ट को नहीं हटाया जाता है।

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

संसाधन ऑब्जेक्ट बनाने और वापस करने का एक टेम्पलेट उदाहरण निम्नलिखित है।

ERL_NIF_TERM term;
MyStruct* obj = enif_alloc_resource(my_resource_type, sizeof(MyStruct));

/* initialize struct ... */

term = enif_make_resource(env, obj);

if (keep_a_reference_of_our_own) {
    /* store 'obj' in static variable, private data or other resource object */
}
else {
    enif_release_resource(obj);
    /* resource now only owned by "Erlang" */
}
return term;

ध्यान दें कि एक बार enif_make_resource शब्द Erlang पर लौटने के लिए बनाता है, कोड आवंटित संरचना में या तो अपने स्वयं के मूल सूचक को रख सकता है और बाद में इसे जारी कर सकता है, या इसे तुरंत जारी कर सकता है और अंततः संसाधन ऑब्जेक्ट को हटाने के लिए कचरा कलेक्टर पर भरोसा कर सकता है जब यह शब्द एकत्र करता है।

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

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

मॉड्यूल उन्नयन और स्थिर डेटा

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

सूत्र और संगति

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

लाइब्रेरी इनिशियलाइज़ेशन कॉलबैक load और upgrade साझा स्टेट डेटा के लिए भी थ्रेड-सेफ हैं।

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

जब NIF लाइब्रेरी बनाई जाती है, NIF API संस्करण के बारे में जानकारी लाइब्रेरी में संकलित की जाती है। जब NIF लाइब्रेरी लोड की जाती है, तो रनटाइम सिस्टम सत्यापित करता है कि लाइब्रेरी एक संगत संस्करण की है। erl_nif.h निम्नलिखित को परिभाषित करता है:

ERL_NIF_MAJOR_VERSION

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

ERL_NIF_MINOR_VERSION

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

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

समय मापन

एनआईएफ पुस्तकालयों में समय मापन के लिए समर्थन:

मैं / हे कतार

Erlang nif लाइब्रेरी में I / O वैक्टर के साथ आसानी से काम करने के लिए फ़ंक्शन होता है जैसा कि यूनिक्स सिस्टम कॉल writev द्वारा उपयोग किया जाता है। I / O कतार थ्रेड सुरक्षित नहीं है, इसलिए कुछ अन्य सिंक्रनाइज़ेशन तंत्र का उपयोग करना होगा।

फ़ाइल डिस्क्रिप्टर पर लिखते समय विशिष्ट उपयोग इस तरह दिखता है:

int writeiovec(ErlNifEnv *env, ERL_NIF_TERM term, ERL_NIF_TERM *tail,
               ErlNifIOQueue *q, int fd) {

    ErlNifIOVec vec, *iovec = &vec;
    SysIOVec *sysiovec;
    int saved_errno;
    int iovcnt, n;

    if (!enif_inspect_iovec(env, 64, term, tail, &iovec))
        return -2;

    if (enif_ioq_size(q) > 0) {
        /* If the I/O queue contains data we enqueue the iovec and
           then peek the data to write out of the queue. */
        if (!enif_ioq_enqv(q, iovec, 0))
            return -3;

        sysiovec = enif_ioq_peek(q, &iovcnt);
    } else {
        /* If the I/O queue is empty we skip the trip through it. */
        iovcnt = iovec->iovcnt;
        sysiovec = iovec->iov;
    }

    /* Attempt to write the data */
    n = writev(fd, sysiovec, iovcnt);
    saved_errno = errno;

    if (enif_ioq_size(q) == 0) {
        /* If the I/O queue was initially empty we enqueue any
           remaining data into the queue for writing later. */
        if (n >= 0 && !enif_ioq_enqv(q, iovec, n))
            return -3;
    } else {
        /* Dequeue any data that was written from the queue. */
        if (n > 0 && !enif_ioq_deq(q, n, NULL))
            return -4;
    }

    /* return n, which is either number of bytes written or -1 if
       some error happened */
    errno = saved_errno;
    return n;
}
लंबे समय से चल रहे एन.आई.एफ.

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

एनआईएफ कॉल की लंबाई के बारे में रनटाइम सिस्टम को सूचित करने के लिए enif_consume_timeslice() फ़ंक्शन का उपयोग किया जा सकता है। यह आमतौर पर हमेशा उपयोग किया जाता है जब तक कि NIF बहुत तेजी से निष्पादित नहीं होता है।

यदि एनआईएफ कॉल बहुत लंबा है, तो इसे निम्नांकित जवाबदेही से बचने के लिए निम्नलिखित तरीकों में से एक में संभाला जाना चाहिए, शेड्यूलर लोड संतुलन की समस्या, और अन्य अजीब व्यवहार:

उपज एनआईएफ

यदि लंबे समय तक चलने वाले एनआईएफ की कार्यक्षमता को विभाजित किया जा सकता है ताकि उसके काम को कम एनआईएफ कॉल की एक श्रृंखला के माध्यम से प्राप्त किया जा सके, तो आवेदन में दो विकल्प हैं:

  • उस श्रृंखला की NIF कॉल को Erlang स्तर से करें।

  • एक enif_schedule_nif को कॉल करें जो पहले काम का एक हिस्सा करता है, फिर अगले chunk प्रदर्शन करने के लिए एक और enif_schedule_nif कॉल शेड्यूल करने के लिए enif_schedule_nif फ़ंक्शन को आमंत्रित करता है। इस तरह से निर्धारित अंतिम कॉल फिर समग्र परिणाम दे सकता है।

इस तरह से लंबे समय तक चलने वाले फ़ंक्शन को तोड़ना वीएम को एनआईएफ को कॉल के बीच नियंत्रण हासिल करने में सक्षम बनाता है।

यह दृष्टिकोण हमेशा नीचे वर्णित अन्य विकल्पों पर पसंद किया जाता है। यह एक प्रदर्शन के दृष्टिकोण और एक प्रणाली विशेषताओं के परिप्रेक्ष्य से दोनों है।

एनआईएफ को पिरोया

यह NIF लाइब्रेरी द्वारा प्रबंधित दूसरे थ्रेड में काम भेजने से पूरा होता है, NIF से वापस आता है, और परिणाम की प्रतीक्षा करता है। थ्रेड enif_send का उपयोग करके परिणाम को Erlang प्रक्रिया में वापस भेज सकता है। थ्रेड प्राइमेटिव के बारे में जानकारी नीचे दी गई है।

गंदा NIF
ध्यान दें

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

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

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

निष्पादन के लिए एक गंदे NIF को निर्धारित करने के लिए, आवेदन के दो विकल्प हैं:

  • अपने ErlNifFunc प्रविष्टि में गंदे ErlNifFunc लिए उपयुक्त झंडे मान सेट करें।

  • enif_schedule_nif कॉल enif_schedule_nif , इसे निष्पादित करने के लिए गंदे enif_schedule_nif को एक पॉइंटर पास करें, और तर्क flags साथ इंगित करें कि क्या यह ऑपरेशन सीपीयू-बाउंड या I / O- बाउंड होने की उम्मीद करता है।

एक नौकरी जो I / O बाउंड और सीपीयू बाउंड के बीच वैकल्पिक हो enif_schedule_nif है, उसे enif_schedule_nif का उपयोग करके पुनर्निर्धारित और पुनर्निर्धारित किया जा सकता है ताकि यह हर समय सही प्रकार के गंदे शेड्यूलर पर निष्पादित हो। अधिक जानकारी के लिए erl(1) कमांड लाइन तर्क +SDcpu , और +SDio

जबकि एक प्रक्रिया एक गंदे NIF को निष्पादित करती है, कुछ ऑपरेशन जो इसके साथ संवाद करते हैं उन्हें पूरा होने में बहुत लंबा समय लग सकता है। गंदे NIF को निष्पादित करने वाली प्रक्रिया का निलंबित या कचरा संग्रहण तब तक नहीं किया जा सकता जब तक कि गंदा NIF वापस नहीं आ जाता। इस प्रकार, ऐसी प्रक्रियाओं के पूरा होने की प्रतीक्षा करने वाली अन्य प्रक्रियाओं को बहुत लंबे समय तक इंतजार करना पड़ सकता है। बहु-शेड्यूलिंग को अवरुद्ध करना, erlang:system_flag(multi_scheduling, block) , कॉलिंग erlang:system_flag(multi_scheduling, block) , को पूरा करने में बहुत लंबा समय लग सकता है। ऐसा इसलिए है क्योंकि ब्लॉक ऑपरेशन पूरा होने से पहले सभी गंदे शेड्यूलर पर चल रहे सभी गंदे ऑपरेशनों को पूरा करना होगा।

एक गंदा NIF निष्पादित करने वाली प्रक्रिया के साथ संचार करने वाले कई ऑपरेशन, हालांकि, यह गंदा NIF निष्पादित करते समय पूरा कर सकते हैं। उदाहरण के लिए, erlang:process_info माध्यम से इसके बारे में जानकारी प्राप्त erlang:process_info , अपने समूह के नेता को स्थापित करना, उसका नाम पंजीकृत करना / अपंजीकृत करना, इत्यादि।

एक गंदे NIF को निष्पादित करने वाली प्रक्रिया की समाप्ति केवल एक निश्चित बिंदु तक पूरी की जा सकती है जबकि यह गंदे NIF को निष्पादित करती है। सभी Erlang संसाधन, जैसे कि इसका पंजीकृत नाम और इसकी ETS तालिकाएँ जारी की गई हैं। सभी लिंक और मॉनिटर ट्रिगर किए गए हैं। NIF का निष्पादन, हालांकि, रोका नहीं गया है। एनआईएफ सुरक्षित रूप से निष्पादन जारी रख सकता है, ढेर मेमोरी आवंटित कर सकता है, और इसी तरह, लेकिन निश्चित रूप से जितनी जल्दी हो सके निष्पादन को रोकना बेहतर है। एनआईएफ यह जांच सकता है कि क्या वर्तमान प्रक्रिया enif_is_current_process_alive का उपयोग करके जीवित है। जब भेजने की प्रक्रिया जीवित न हो, तो enif_send और enif_port_command का उपयोग करके संचार भी गिरा दिया जाता है। कुछ आंतरिक संसाधनों, जैसे कि प्रोसेस हीप और प्रोसेस कंट्रोल ब्लॉक का डीक्लोकेशन, जब तक गंदा एनआईएफ पूरा नहीं हो जाता, तब तक देरी हो जाती है।

प्रारंभ

ERL_NIF_INIT(MODULE, ErlNifFunc funcs[], load, NULL, upgrade, unload)

यह NIF लाइब्रेरी को इनिशियलाइज़ करने के लिए मैजिक मैक्रो है। इसका मूल्यांकन वैश्विक फ़ाइल दायरे में किया जाना है।

MODULE स्ट्रिंग कोटेशन के बिना एक पहचानकर्ता के रूप में एरलंग मॉड्यूल का नाम है। यह मैक्रो द्वारा कठोर है।

funcs इस लाइब्रेरी में सभी कार्यान्वित NIF के लिए फ़ंक्शन डिस्क्रिप्टर का एक स्थिर सरणी है।

load , upgrade और unload कार्य के लिए संकेत हैं। पुस्तकालय को आरंभ करने के लिए load या upgrade एक कहा जाता है। लायब्रेरी को जारी करने के लिए unload कहा जाता है। सभी को नीचे व्यक्तिगत रूप से वर्णित किया गया है।

चौथे तर्क NULL को अनदेखा किया गया है। पहले इसका उपयोग अपदस्थ reload कॉलबैक के लिए किया गया था जो अब ओटीपी 20 के बाद से समर्थित नहीं है।

यदि --enable-static-nifs माध्यम से स्थैतिक समावेशन के लिए --enable-static-nifs , तो आपको ERL_NIF_INIT घोषणा से पहले STATIC_ERLANG_NIF को परिभाषित करना होगा।

int (*load)(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)

load को उस समय कहा जाता है जब NIF लाइब्रेरी लोड होती है और इस मॉड्यूल के लिए पहले लोडेड लाइब्रेरी मौजूद नहीं है।

*priv_data को कुछ निजी डेटा को इंगित करने के लिए सेट किया जा सकता है यदि पुस्तकालय को एनआईएफ कॉल के बीच एक राज्य रखने की आवश्यकता होती है। enif_priv_data इस सूचक को लौटाता है। *priv_data को NULL लिए इनिशियलाइज़ किया जाता NULL जब load कहा जाता है।

load_info erlang:load_nif/2 का दूसरा तर्क है erlang:load_nif/2

यदि load 0 अलावा कुछ और रिटर्न देता है तो लाइब्रेरी लोड करने में विफल रहती है। यदि आरंभीकरण की आवश्यकता नहीं है तो load NULL हो सकता NULL

int (*upgrade)(ErlNifEnv* env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info)

एनआईएफ लाइब्रेरी लोड होने पर upgrade कहा जाता है और लोड एनआईएफ लाइब्रेरी के साथ इस मॉड्यूल का पुराना कोड है।

load रूप में काम करता load , सिवाय इसके कि *old_priv_data में पुराने मॉड्यूल कोड के लिए load या upgrade लिए अंतिम कॉल द्वारा निर्धारित मूल्य होता है। *priv_data को NULL लिए इनिशियलाइज़ किया जाता NULL जब upgrade कहते हैं। इसे *priv_data और *old_priv_data. दोनों को लिखने की अनुमति है *old_priv_data.

यदि upgrade 0 अलावा कुछ भी देता है या upgrade NULL है तो लाइब्रेरी लोड करने में विफल NULL

void (*unload)(ErlNifEnv* env, void* priv_data)

unload को उस समय कहा जाता है जब NIF लाइब्रेरी के मॉड्यूल कोड को पुराने के रूप में शुद्ध किया जाता है। एक ही मॉड्यूल का नया कोड मौजूद हो सकता है या नहीं भी।

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

ERL_NIF_TERM

ERL_NIF_TERM प्रकार के चर किसी भी Erlang शब्द को संदर्भित कर सकते हैं। यह एक अपारदर्शी प्रकार है और इसका मान केवल API फ़ंक्शन के तर्क के रूप में या NIF से वापसी मान के रूप में उपयोग किया जा सकता है। सभी ERL_NIF_TERM पर्यावरण ( ErlNifEnv ) से संबंधित हैं। एक शब्द को व्यक्तिगत रूप से नष्ट नहीं किया जा सकता है, यह तब तक मान्य है जब तक इसका पर्यावरण नष्ट नहीं हो जाता।

ErlNifEnv

ErlNifEnv एक ऐसे वातावरण का प्रतिनिधित्व करता है जो Erlang शब्दों की मेजबानी कर सकता है। एक वातावरण में सभी शर्तें मान्य हैं जब तक कि पर्यावरण वैध है। ErlNifEnv एक अपारदर्शी प्रकार है; इसे इंगित करने वाले को केवल API फ़ंक्शन पर ही पास किया जा सकता है। दो प्रकार के वातावरण मौजूद हैं:

प्रक्रिया-बद्ध वातावरण

सभी एनआईएफ के लिए पहला तर्क पारित किया। NIF को दिए गए सभी फ़ंक्शन तर्क उस वातावरण से संबंधित हैं। एनआईएफ से वापसी मूल्य भी उसी पर्यावरण से संबंधित शब्द होना चाहिए।

एक प्रक्रिया-बाउंड वातावरण में कॉलिंग Erlang प्रक्रिया के बारे में क्षणिक जानकारी होती है। पर्यावरण केवल उस थ्रेड में मान्य होता है जहां इसे NIF के लौटने तक तर्क के रूप में आपूर्ति की गई थी। इस प्रकार NIF कॉल के बीच वातावरण को प्रोसेस करने के लिए पॉइंटर्स को स्टोर करना बेकार और खतरनाक है।

प्रक्रिया-स्वतंत्र वातावरण

enif_alloc_env को कॉल करके बनाया गया। इस वातावरण का उपयोग enif_send कॉल के बीच शब्दों को संग्रहीत करने और enif_send साथ शर्तें भेजने के लिए किया जा सकता है। जब तक आप स्पष्ट रूप से इसे enif_free_env या enif_send साथ अमान्य नहीं करते, तब तक इसकी सभी शर्तों के साथ एक प्रक्रिया-स्वतंत्र वातावरण मान्य है।

सूची / टपल / मानचित्र के सभी समाहित शब्द सूची / टपल / मानचित्र के समान वातावरण के होने चाहिए। शर्तों को पर्यावरण के बीच में enif_make_copy साथ कॉपी किया जा सकता है।

ErlNifFunc
typedef struct {
    const char* name;
    unsigned arity;
    ERL_NIF_TERM (*fptr)(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
    unsigned flags;
} ErlNifFunc;

एक NIF को इसके नाम, गुण और कार्यान्वयन के द्वारा बताता है।

fptr

एनआईएफ को लागू करने वाले फ़ंक्शन के लिए एक सूचक।

argv

NIF को दिए गए फ़ंक्शन आर्गुमेंट्स शामिल हैं।

argc

सरणी की लंबाई, अर्थात्, फ़ंक्शन की अरेटी। argv[N-1] इस प्रकार NIF तर्क को NIF को दर्शाता है। ध्यान दें कि तर्क argc एक ही C फ़ंक्शन के लिए अलग-अलग एरिटी (लेकिन संभवतः एक ही नाम के साथ) को लागू करने की अनुमति देता है।

flags

एक नियमित एनआईएफ के लिए 0 (और इसलिए इसका मूल्य ErlNifFunc रूप से प्रारंभिक ErlNifFunc उदाहरणों के लिए छोड़ा जा सकता है)।

flags का उपयोग यह इंगित करने के लिए किया जा सकता है कि NIF एक dirty NIF जिसे गंदे शेड्यूलर थ्रेड पर निष्पादित किया जाना है।

यदि गंदे ERL_NIF_DIRTY_JOB_CPU_BOUND को सीपीयू-बाउंड होने की उम्मीद है, तो इसके flags फ़ील्ड को ERL_NIF_DIRTY_JOB_CPU_BOUND या ERL_NIF_DIRTY_JOB_IO_BOUND सेट किया ERL_NIF_DIRTY_JOB_IO_BOUND

ध्यान दें

यदि ERL_NIF_DIRTY_JOB_*_BOUND झंडे में से एक सेट है, और रनटाइम सिस्टम में गंदे शेड्यूलर्स के लिए कोई समर्थन नहीं है, तो रनटाइम सिस्टम NIF लाइब्रेरी को लोड करने से इनकार करता है।

ErlNifBinary
typedef struct {
    unsigned size;
    unsigned char* data;
} ErlNifBinary;

ErlNifBinary में एक निरीक्षण बाइनरी शब्द के बारे में क्षणिक जानकारी होती है। data बाइनरी के कच्चे माल के साथ size बाइट्स के एक बफर के लिए एक संकेतक है।

ध्यान दें कि ErlNifBinary एक अर्ध-अपारदर्शी प्रकार है और आपको केवल फ़ील्ड size और data पढ़ने की अनुमति है।

ErlNifBinaryToTerm

विकल्पों की एक गणना जो enif_binary_to_term को निर्दिष्ट की जा enif_binary_to_term । डिफ़ॉल्ट व्यवहार के लिए, मान 0 उपयोग करें।

अविश्वसनीय स्रोतों से डेटा प्राप्त करते समय, विकल्प ERL_NIF_BIN2TERM_SAFE उपयोग करें।

ErlNifMonitor

यह एक अपारदर्शी डेटा प्रकार है जो एक मॉनिटर की पहचान करता है।

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

ErlNifPid

एक प्रक्रिया पहचानकर्ता (pid)। पीआईडी ​​शब्दों के विपरीत ( ERL_NIF_TERM उदाहरण), ErlNifPid s स्वयं सम्‍मिलित हैं और किसी भी ErlNifEnv लिए बाध्य नहीं ErlNifEnv ErlNifPid एक अपारदर्शी प्रकार है।

ErlNifPort

एक बंदरगाह पहचानकर्ता। पोर्ट आईडी शर्तों ( ERL_NIF_TERM उदाहरण) के ERL_NIF_TERM , ErlNifPort s किसी भी ErlNifEnv स्वयं-निहित और बाध्य नहीं ErlNifEnv ErlNifPort एक अपारदर्शी प्रकार है।

ErlNifResourceType

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

ErlNifResourceTypeInit
typedef struct {
    ErlNifResourceDtor* dtor;
    ErlNifResourceStop* stop;
    ErlNifResourceDown* down;
} ErlNifResourceTypeInit;

प्रारंभिक संरचना enif_open_resource_type_x द्वारा पढ़ी गई।

ErlNifResourceDtor
typedef void ErlNifResourceDtor(ErlNifEnv* env, void* obj);

एक संसाधन विध्वंसक फ़ंक्शन का फ़ंक्शन प्रोटोटाइप।

obj तर्क संसाधन का सूचक है। विध्वंसक में संसाधन के लिए एकमात्र अनुमत उपयोग अपने उपयोगकर्ता डेटा को एक अंतिम बार एक्सेस करना है। संसाधन से निपटने से पहले विध्वंसक अंतिम कॉलबैक होने की गारंटी है।

ErlNifResourceDown
typedef void ErlNifResourceDown(ErlNifEnv* env, void* obj, ErlNifPid* pid, ErlNifMonitor* mon);

एक संसाधन डाउन फ़ंक्शन का फ़ंक्शन प्रोटोटाइप, जिसे enif_monitor_process की ओर से बुलाया गया है। obj संसाधन है, pid निगरानी प्रक्रिया की पहचान है जो बाहर निकल रही है, और mon मॉनिटर की पहचान है।

ErlNifResourceStop
typedef void ErlNifResourceStop(ErlNifEnv* env, void* obj, ErlNifEvent event, int is_direct_call);

संसाधन स्टॉप फ़ंक्शन का फ़ंक्शन प्रोटोटाइप, जिसे enif_select की ओर से बुलाया गया है। obj संसाधन है, event OS इवेंट है, is_direct_call सच है अगर कॉल सीधे enif_select या झूठे से किया जाता है अगर यह एक अनुसूचित कॉल है (संभावित रूप से दूसरे थ्रेड से)।

ErlNifCharEncoding
typedef enum {
    ERL_NIF_LATIN1
}ErlNifCharEncoding;

तार और परमाणुओं में प्रयुक्त चरित्र एन्कोडिंग। आईएसओ लैटिन -1 (8-बिट ASCII) के लिए एकमात्र समर्थित एन्कोडिंग ERL_NIF_LATIN1

ErlNifSysInfo

रनटाइम सिस्टम के बारे में जानकारी वापस करने के लिए enif_system_info() द्वारा उपयोग किया जाता है। इसमें ErlDrvSysInfo जैसी सामग्री है।

ErlNifSInt64

एक देशी हस्ताक्षर 64-बिट पूर्णांक प्रकार।

ErlNifUInt64

एक देशी अहस्ताक्षरित 64-बिट पूर्णांक प्रकार।

ErlNifTime

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

ErlNifTimeUnit

एनआईएफ एपीआई द्वारा समर्थित समय इकाइयों की गणना:

ERL_NIF_SEC
सेकंड
ERL_NIF_MSEC
मिलीसेकंड
ERL_NIF_USEC
माइक्रोसेकंड
ERL_NIF_NSEC
नैनोसेकंड
ErlNifUniqueInteger

गुणों की एक गणना जिसे enif_make_unique_integer से अनुरोध किया जा सकता है। डिफ़ॉल्ट गुणों के लिए, मान 0 उपयोग करें।

ERL_NIF_UNIQUE_POSITIVE

केवल सकारात्मक पूर्णांक लौटाएं।

ERL_NIF_UNIQUE_MONOTONIC

सृजन के समय के अनुसार strictly monotonically increasing पूर्णांक में लौटें।

ErlNifHash

समर्थित हैश प्रकारों की गणना जो enif_hash का उपयोग करके उत्पन्न की जा सकती है।

ERL_NIF_INTERNAL_HASH

गैर-पोर्टेबल हैश फ़ंक्शन जो केवल एक Erlang VM उदाहरण के भीतर एक ही शब्द के लिए एक ही हैश की गारंटी देता है।

यह 32-बिट नमक मान लेता है और 0..2^32-1 भीतर हैश उत्पन्न करता है।

ERL_NIF_PHASH2

पोर्टेबल हैश फ़ंक्शन जो मशीन आर्किटेक्चर और ईआरटीएस संस्करण की परवाह किए बिना एक ही एरलंग शब्द के लिए एक ही हैश देता है।

यह नमक के मूल्यों की अनदेखी करता है और 0..2^27-1 भीतर हैश उत्पन्न करता है।

ERL_NIF_INTERNAL_HASH. तुलना में ERL_NIF_INTERNAL_HASH. यह erlang:phash2/1 मेल खाती है erlang:phash2/1

SysIOVec

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

ErlNifIOVec
typedef struct {
  int iovcnt;
  size_t size;
  SysIOVec* iov;
} ErlNifIOVec;

I / O वेक्टर जिसमें iovcnt SysIOVec है, जो डेटा की ओर इशारा करता है। इसका उपयोग enif_inspect_iovec() और enif_ioq_enqv() द्वारा किया जाता है।

ErlNifIOQueueOpts
एक ErlNifIOQueue कॉन्फ़िगर करने के लिए विकल्प।
ERL_NIF_IOQ_NORMAL

एक सामान्य I / O कतार बनाएँ

निर्यात

void *enif_alloc(size_t size)

size बाइट्स की स्मृति आवंटित करता है।

आवंटन विफल होने पर NULL लौटाता NULL

लौटे हुए पॉइंटर को किसी भी अंतर्निहित प्रकार के लिए उपयुक्त रूप से संरेखित किया गया है जो आवंटित मेमोरी में फिट होता है।

int enif_alloc_binary(size_t size, ErlNifBinary* bin)

आकार size बाइट्स का एक नया बाइनरी आवंटित करता है। आवंटित बाइनरी को संदर्भित करने के लिए bin द्वारा इंगित की गई संरचना को आरम्भ करता है। बाइनरी को या तो enif_release_binary द्वारा जारी किया जाना चाहिए या enif_release_binary साथ एक Erlang पद पर स्थानांतरित किया जाना चाहिए। एक आवंटित (और स्वामित्व वाली) ErlNifBinary को ErlNifBinary कॉल के बीच रखा जा सकता है।

यदि आपको एनआईएफ कॉल के दौरान डेटा को फिर से लाने या जीवित रखने की आवश्यकता नहीं है, तो इसके बजाय enif_make_new_binary का उपयोग करने पर विचार करें क्योंकि यह संभव होने पर प्रक्रिया हीप पर छोटे बायनेरिज़ आवंटित करेगा।

आवंटन विफल होने पर सफलता, या false पर true लौटाता true

ErlNifEnv *enif_alloc_env()

एक नई प्रक्रिया-स्वतंत्र वातावरण आवंटित करता है। पर्यावरण का उपयोग ऐसे शब्दों को रखने के लिए किया जा सकता है जो किसी भी प्रक्रिया के लिए बाध्य नहीं हैं। इस तरह की शर्तों को बाद में enif_make_copy साथ प्रोसेस वातावरण में कॉपी किया जा सकता है या enif_make_copy वाले संदेश के रूप में एक प्रक्रिया में भेजा जा सकता है।

नए वातावरण के लिए सूचक लौटाता है।

void *enif_alloc_resource(ErlNifResourceType* type, unsigned size)

type और आकार size बाइट्स की स्मृति-प्रबंधित संसाधन ऑब्जेक्ट आवंटित करता है।

size_t enif_binary_to_term(ErlNifEnv *env, const unsigned char* data, size_t size, ERL_NIF_TERM *term, ErlNifBinaryToTerm opts)

एक शब्द बनाता है जो डेटा पर द्विआधारी डेटा को डिकोड करने का परिणाम है, जिसे एर्लांग बाहरी शब्द प्रारूप के अनुसार एन्कोड किया जाना चाहिए। size बाइट्स से अधिक data से नहीं पढ़े जाते हैं। तर्क opts erlang:binary_to_term/2 के दूसरे तर्क से मेल खाता है erlang:binary_to_term/2 और 0 या ERL_NIF_BIN2TERM_SAFE होना चाहिए।

सफलता पर, परिणामी शब्द को *term पर संग्रहीत करता है और पढ़ी जाने वाली बाइट्स की संख्या लौटाता है। यदि डिकोडिंग विफल हो जाती है या यदि opts अमान्य है, तो रिटर्न 0

ErlNifBinaryToTerm , erlang:binary_to_term/2 और enif_term_to_binary भी देखें।

void enif_clear_env(ErlNifEnv* env)

एक वातावरण में सभी शर्तों को जोड़ता है और इसे पुन: उपयोग के लिए साफ करता है। पर्यावरण को enif_alloc_env साथ आवंटित किया जाना चाहिए।

int enif_compare(ERL_NIF_TERM lhs, ERL_NIF_TERM rhs)

एक पूर्णांक लौटाता है < 0 यदि lhs < rhs , 0 यदि lhs = rhs , और> 0 यदि lhs > rhs । एरलैंग ऑपरेटरों के अनुरूप == , /= , =< , < , >= , और > (लेकिन नहीं =:= या =/= )।

int enif_compare_monitors(const ErlNifMonitor *monitor1, const ErlNifMonitor *monitor2)

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

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

void enif_cond_broadcast(ErlNifCond *cnd)

erl_drv_cond_broadcast समान।

ErlNifCond *enif_cond_create(char *name)

erl_drv_cond_create समान।

void enif_cond_destroy(ErlNifCond *cnd)

erl_drv_cond_destroy समान।

char*enif_cond_name(ErlNifCond* cnd)

erl_drv_cond_name समान।

void enif_cond_signal(ErlNifCond *cnd)

erl_drv_cond_signal समान।

void enif_cond_wait(ErlNifCond *cnd, ErlNifMutex *mtx)

erl_drv_cond_wait समान।

int enif_consume_timeslice(ErlNifEnv *env, int percent)

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

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

तर्क percent 1 और 100 के बीच पूर्णांक होना चाहिए। इस फ़ंक्शन को केवल एनआईएफ-कॉलिंग थ्रेड से बुलाया जाना चाहिए, और तर्क env को कॉलिंग प्रक्रिया का env होना चाहिए।

1 अगर समय समाप्त हो जाता है, तो रिटर्न 1 , अन्यथा 0 । यदि 1 लौटाया जाता है, तो एनआईएफ को उपज की प्रक्रिया के लिए जल्द से जल्द वापस लौटना होगा।

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

इस मैनुअल पृष्ठ की शुरुआत में warning पाठ भी देखें।

ErlNifTime enif_convert_time_unit(ErlNifTime val, ErlNifTimeUnit from, ErlNifTimeUnit to)

समय इकाई के संबंधित मान से समय इकाई के मान को परिवर्तित करता to । फर्श फ़ंक्शन का उपयोग करके परिणाम को गोल किया जाता है।

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

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

ErlNifTime और ErlNifTimeUnit भी देखें।

ERL_NIF_TERM enif_cpu_time(ErlNifEnv *)

erlang:timestamp() रूप में एक ही प्रारूप में CPU समय देता है erlang:timestamp() । सीपीयू समय वह समय होता है जब वर्तमान तार्किक सीपीयू ने अतीत में कुछ मनमाने बिंदु के बाद से निष्पादन को खर्च किया है। यदि OS इस मान को लाने का समर्थन नहीं करता है, तो enif_cpu_time आमंत्रित करता है।

int enif_demonitor_process(ErlNifEnv* env, void* obj, const ErlNifMonitor* mon)

पहले enif_monitor_process साथ बनाया गया एक मॉनिटर रद्द करता है। तर्क obj निगरानी रखने वाले संसाधन का एक संकेतक है और *mon मॉनिटर की पहचान करता है।

रिटर्न 0 अगर मॉनिटर को सफलतापूर्वक पहचान लिया गया और हटा दिया गया। यदि कोई मॉनीटर पहचाना नहीं जा सकता, तो गैर-शून्य मान देता है, जिसका अर्थ है कि यह या तो था

  • इस संसाधन के लिए कभी नहीं बनाया गया
  • पहले ही रद्द कर दिया गया
  • पहले से ही ट्रिगर
  • बस एक समवर्ती धागे द्वारा ट्रिगर किया जाएगा

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

int enif_equal_tids(ErlNifTid tid1, ErlNifTid tid2)

erl_drv_equal_tids समान।

int enif_fprintf(FILE *stream, const char *format, ...)

fprintf समान लेकिन यह प्रारूप स्ट्रिंग "%T" भी स्वीकार करता है, जो Erlang शब्दों को प्रारूपित करता है।

यह फ़ंक्शन मूल रूप से डीबगिंग उद्देश्य के लिए इरादा था। इसके साथ बहुत बड़ी शर्तें मुद्रित करने की अनुशंसा नहीं की जाती है %T । समारोह errno सफल होने पर भी बदल सकता है ।

void enif_free(void* ptr)

द्वारा आवंटित की गई मेमोरी मेमोरी enif_alloc

void enif_free_env(ErlNifEnv* env)

एक पर्यावरण के साथ आवंटित पर्यावरण enif_alloc_env । वातावरण में निर्मित सभी शर्तों को भी मुक्त कर दिया जाता है।

void enif_free_iovec(ErlNifIOvec* iov)

पेड़ एक io वेक्टर से लौटे enif_inspect_iovec() । यह तभी आवश्यक है जब NULL पर्यावरण को पारित किया जाए enif_inspect_iovec()

ErlNifIOVec *iovec = NULL;
size_t max_elements = 128;
ERL_NIF_TERM tail;
if (!enif_inspect_iovec(NULL, max_elements, term, &tail, &iovec))
  return 0;

// Do things with the iovec

/* Free the iovector, possibly in another thread or nif function call */
enif_free_iovec(iovec);

int enif_get_atom(ErlNifEnv* env, ERL_NIF_TERM term, char* buf, unsigned size, ErlNifCharEncoding encode)

एन्कोडिंग के साथ परमाणु के स्ट्रिंग प्रतिनिधित्व से मिलकर, आकार NULL द्वारा इंगित बफर में एक -स्ट्रिंग स्ट्रिंग लिखता है । buf size term encode

लिखित बाइट्स की संख्या लौटाता है ( NULL वर्ण समाप्त करने सहित ) या 0 यदि term अधिकतम लंबाई वाला परमाणु नहीं है size-1

int enif_get_atom_length(ErlNifEnv* env, ERL_NIF_TERM term, unsigned* len, ErlNifCharEncoding encode)

एन्कोडिंग के साथ परमाणु *len की लंबाई (बाइट्स को समाप्त करने वाले NULL वर्ण को छोड़कर ) पर सेट करता है । term encode

रिटर्न true सफलता पर, या false अगर term एक परमाणु नहीं है।

int enif_get_double(ErlNifEnv* env, ERL_NIF_TERM term, double* dp)

*dp के फ़्लोटिंग-पॉइंट मान पर सेट करता है term

true सफलता पर रिटर्न , या false अगर term एक फ्लोट नहीं है।

int enif_get_int(ErlNifEnv* env, ERL_NIF_TERM term, int* ip)

*ip के पूर्णांक मान पर सेट करता है term

true सफलता पर रिटर्न , या false यदि term पूर्णांक नहीं है या प्रकार की सीमा के बाहर है int

int enif_get_int64(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifSInt64* ip)

*ip के पूर्णांक मान पर सेट करता है term

true सफलता पर रिटर्न , या false यदि term एक पूर्णांक नहीं है या एक हस्ताक्षरित 64-बिट पूर्णांक की सीमा के बाहर है।

int enif_get_local_pid(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPid* pid)

यदि term एक नोड स्थानीय प्रक्रिया का pid है, तो यह फ़ंक्शन *pid इसमें से pid वैरिएबल को इनिशियलाइज़ करता है और लौटता है true । अन्यथा false लौट आता false । यह देखने के लिए कोई जाँच नहीं की जाती है कि क्या यह प्रक्रिया जीवित है।

int enif_get_local_port(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPort* port_id)

यदि term एक नोड स्थानीय पोर्ट की पहचान करता है, तो यह फ़ंक्शन पोर्ट चर *port_id को इससे आरंभ करता है और वापस लौटता है true । अन्यथा false लौट आता false । यह देखने के लिए कोई जाँच नहीं की जाती है कि पोर्ट जीवित है या नहीं।

int enif_get_list_cell(ErlNifEnv* env, ERL_NIF_TERM list, ERL_NIF_TERM* head, ERL_NIF_TERM* tail)

सेट *head और *tail सूची से list

true सफलता पर रिटर्न , या false अगर यह सूची नहीं है या सूची खाली है।

int enif_get_list_length(ErlNifEnv* env, ERL_NIF_TERM term, unsigned* len)

*len सूची की लंबाई के लिए सेट term

true सफलता पर रिटर्न , या false यदि term एक उचित सूची नहीं है।

int enif_get_long(ErlNifEnv* env, ERL_NIF_TERM term, long int* ip)

*ip के लंबे पूर्णांक मान पर सेट होता है term

true सफलता पर रिटर्न , या false यदि term पूर्णांक नहीं है या प्रकार की सीमा के बाहर है long int

int enif_get_map_size(ErlNifEnv* env, ERL_NIF_TERM term, size_t *size)

*size नक्शे में कुंजी-मूल्य जोड़े की संख्या के लिए सेट term

true सफलता पर लौटा , या false अगर term एक नक्शा नहीं है।

int enif_get_map_value(ErlNifEnv* env, ERL_NIF_TERM map, ERL_NIF_TERM key, ERL_NIF_TERM* value)

मानचित्र में *value संबद्ध मान पर सेट करता है । key map

true सफलता पर वापसी करता है, या false यदि map कोई नक्शा नहीं है या यदि map नहीं है key

int enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* type, void** objp)

*objp द्वारा संदर्भित संसाधन ऑब्जेक्ट को इंगित करने के लिए सेट करता है term

रिटर्न true सफलता पर, या false अगर term प्रकार का एक संसाधन ऑब्जेक्ट में एक संभाल नहीं है type

int enif_get_string(ErlNifEnv* env, ERL_NIF_TERM list, char* buf, unsigned size, ErlNifCharEncoding encode)

एक NULL स्ट्रिंग में वर्णों से मिलकर, buf आकार के द्वारा इंगित बफर में स्ट्रिंग लिखता है । वर्ण एन्कोडिंग का उपयोग करके लिखे गए हैं । size list encode

निम्न में से एक लौटाता है:

  • लिखित बाइट्स की संख्या ( NULL वर्ण समाप्त करने सहित )
  • -size यदि बफर स्थान की वजह से तार काट दिया गया था
  • 0 यदि list वह स्ट्रिंग नहीं है जिसे साथ एन्कोड किया जा सकता है encode या यदि size <था 1

NULL जब तक बफ़र size < नहीं लिखा जाता है , तब तक लिखित स्ट्रिंग हमेशा- नियंत्रित होती है 1

int enif_get_tuple(ErlNifEnv* env, ERL_NIF_TERM term, int* arity, const ERL_NIF_TERM** array)

यदि term एक ट्यूपल है, तो यह फ़ंक्शन *array एक सरणी को इंगित करता है जिसमें टपल के तत्व हैं, और *arity तत्वों की संख्या पर सेट है। ध्यान दें कि सरणी केवल-पढ़ने (*array)[N-1] के लिए है और टपल का Nth तत्व है। *array टडले की धमनी शून्य होने पर अपरिभाषित होती है।

रिटर्न true सफलता पर, या false अगर term एक टपल नहीं है।

int enif_get_uint(ErlNifEnv* env, ERL_NIF_TERM term, unsigned int* ip)

*ip के अहस्ताक्षरित पूर्णांक मान पर सेट करता है term

true सफलता पर रिटर्न , या false अगर term एक अहस्ताक्षरित पूर्णांक नहीं है या प्रकार की सीमा के बाहर है unsigned int

int enif_get_uint64(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifUInt64* ip)

*ip के अहस्ताक्षरित पूर्णांक मान पर सेट करता है term

true सफलता पर रिटर्न , या false अगर term एक अहस्ताक्षरित पूर्णांक नहीं है या एक अहस्ताक्षरित 64-बिट पूर्णांक की सीमा के बाहर है।

int enif_get_ulong(ErlNifEnv* env, ERL_NIF_TERM term, unsigned long* ip)

*ip के अहस्ताक्षरित लंबे पूर्णांक मान पर सेट करता है term

true सफलता पर रिटर्न , या false अगर term एक अहस्ताक्षरित पूर्णांक नहीं है या प्रकार की सीमा के बाहर है unsigned long

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

के रूप में ही erl_drv_getenv

int enif_has_pending_exception(ErlNifEnv* env, ERL_NIF_TERM* reason)

true यदि एक लंबित अपवाद पर्यावरण के साथ जुड़ा हुआ है, तो लौटाता है env । यदि reason कोई NULL सूचक है, तो इसे अनदेखा करें। अन्यथा, यदि कोई लंबित अपवाद env मौजूद है, *reason तो अपवाद शब्द के मान पर सेट करें। उदाहरण के लिए, यदि enif_make_badarg लंबित badarg अपवाद सेट करने के लिए कहा जाता है , तो परमाणु को enif_has_pending_exception(env, &reason) सेट *reason करने के लिए बाद में कॉल किया जाता है badarg , फिर वापस लौटें true

यह भी देखें enif_make_badarg और enif_raise_exception

ErlNifUInt64 enif_hash(ErlNifHash type, ERL_NIF_TERM term, ErlNifUInt64 salt)

term निर्दिष्ट के अनुसार हैश ErlNifHash type

लिया नमक की रेंज (यदि कोई हो) और लौटाया गया मूल्य हैश प्रकार पर निर्भर करता है।

int enif_inspect_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term, ErlNifBinary* bin)

bin द्विआधारी शब्द के बारे में जानकारी के साथ द्वारा बताई गई संरचना को प्रारंभ करता है bin_term

true सफलता पर रिटर्न , या false अगर bin_term एक बाइनरी नहीं है।

int enif_inspect_iolist_as_binary(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifBinary* bin)

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

रिटर्न true सफलता पर, या false अगर iolist एक iolist नहीं है।

int enif_inspect_iovec(ErlNifEnv* env, size_t max_elements, ERL_NIF_TERM iovec_term, ERL_NIF_TERM* tail, ErlNifIOVec** iovec)

iovec में प्रदान की गई बायनेरिज़ की सूची के साथ भरता है iovec_term । कॉल में संभाले गए तत्वों की संख्या सीमित है max_elements , और tail सूची के शेष पर सेट है। ध्यान दें कि आउटपुट max_elements कुछ प्लेटफार्मों पर की तुलना में अधिक लंबा हो सकता है।

एक मनमाने आयोलिस्ट से बायनेरिज़ की सूची बनाने के लिए, उपयोग करें erlang:iolist_to_iovec/1

इस फ़ंक्शन को कॉल करते समय, iovec एक पॉइंटर NULL या एक ErlNifIOVec संरचना को शामिल करना चाहिए जिसे यदि संभव हो तो उपयोग किया जाना चाहिए। जैसे

/* Don't use a pre-allocated structure */
ErlNifIOVec *iovec = NULL;
enif_inspect_iovec(env, max_elements, term, &tail, &iovec);

/* Use a stack-allocated vector as an optimization for vectors with few elements */
ErlNifIOVec vec, *iovec = &vec;
enif_inspect_iovec(env, max_elements, term, &tail, &iovec);

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

true सफलता पर वापसी , या नहीं false तो iovec_term iovec।

ErlNifIOQueue *enif_ioq_create(ErlNifIOQueueOpts opts)

एक नया I / O कतार बनाएं जिसका उपयोग डेटा संग्रहीत करने के लिए किया जा सकता है। opts के लिए सेट किया जाना है ERL_NIF_IOQ_NORMAL

void enif_ioq_destroy(ErlNifIOQueue *q)

I / O कतार को नष्ट करें और इसे सभी सामग्री से मुक्त करें

int enif_ioq_deq(ErlNifIOQueue *q, size_t count, size_t *size)

count I / O कतार से डीक्यू बाइट्स। यदि size नहीं NULL , तो कतार का नया आकार वहां रखा गया है।

true सफलता पर रिटर्न , या false अगर I / O में count बाइट्स नहीं हैं । असफल होने पर कतार को बिना बदले छोड़ दिया जाता है।

int enif_ioq_enq_binary(ErlNifIOQueue *q, ErlNifBinary *bin, size_t skip)

Enqueue bin में q पहले लंघन skip बाइट्स।

रिटर्न true सफलता पर, या false यदि skip का आकार से अधिक है bin । बाइनरी डेटा के किसी भी स्वामित्व को कतार में स्थानांतरित bin किया जाता है और इसे केवल एनआईएफ के बाकी कॉल के लिए और फिर जारी किए जाने के लिए केवल पढ़ने के लिए माना जाता है।

int enif_ioq_enqv(ErlNifIOQueue *q, ErlNifIOVec *iovec, size_t skip)

Enqueue iovec में q पहले लंघन skip बाइट्स।

रिटर्न true सफलता पर, या false यदि skip का आकार से अधिक है iovec

SysIOVec *enif_ioq_peek(ErlNifIOQueue *q, int *iovlen)

I / O कतार को सूचक के रूप में प्राप्त करें SysIOVec । यह तत्वों की संख्या भी लौटाता है iovlen

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

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

int enif_ioq_peek_head(ErlNifEnv *env, ErlNifIOQueue *q, size_t *size, ERL_NIF_TERM *bin_term)

एक द्विआधारी शब्द के रूप में IO कतार का प्रमुख प्राप्त करें।

यदि size नहीं है NULL , तो सिर का आकार वहां रखा गया है।

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

रिटर्न true सफलता पर, या false कतार खाली है यदि।

size_t enif_ioq_size(ErlNifIOQueue *q)

का आकार प्राप्त करें q

int enif_is_atom(ErlNifEnv* env, ERL_NIF_TERM term)

रिटर्न true अगर term एक परमाणु है।

int enif_is_binary(ErlNifEnv* env, ERL_NIF_TERM term)

true अगर term बाइनरी है तो रिटर्न करता है।

int enif_is_current_process_alive(ErlNifEnv* env)

true यदि वर्तमान में निष्पादित प्रक्रिया वर्तमान में जीवित है, तो वापस लौटाता है, अन्यथा false

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

int enif_is_empty_list(ErlNifEnv* env, ERL_NIF_TERM term)

true यदि term रिक्त सूची है, तो लौटाता है।

int enif_is_exception(ErlNifEnv* env, ERL_NIF_TERM term)

अगर term अपवाद है तो सच्चा लौटें ।

int enif_is_fun(ErlNifEnv* env, ERL_NIF_TERM term)

रिटर्न true अगर term एक मजेदार है।

int enif_is_identical(ERL_NIF_TERM lhs, ERL_NIF_TERM rhs)

true यदि दो शब्द समान हैं तो लौटाता है । Erlang ऑपरेटरों के अनुरूप है =:= और =/=

int enif_is_list(ErlNifEnv* env, ERL_NIF_TERM term)

true यदि term सूची है तो लौटाता है।

int enif_is_map(ErlNifEnv* env, ERL_NIF_TERM term)

true अगर term नक्शा है, तो वापस कर दें false

int enif_is_number(ErlNifEnv* env, ERL_NIF_TERM term)

true अगर term एक नंबर है तो लौटाता है।

int enif_is_pid(ErlNifEnv* env, ERL_NIF_TERM term)

रिटर्न true अगर term एक पीआईडी ​​है।

int enif_is_port(ErlNifEnv* env, ERL_NIF_TERM term)

पोर्ट है true तो लौटाता term है।

int enif_is_port_alive(ErlNifEnv* env, ErlNifPort *port_id)

रिटर्न true अगर port_id जीवित है।

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

int enif_is_process_alive(ErlNifEnv* env, ErlNifPid *pid)

रिटर्न true अगर pid जीवित है।

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

int enif_is_ref(ErlNifEnv* env, ERL_NIF_TERM term)

true यदि term संदर्भ है तो लौटाता है।

int enif_is_tuple(ErlNifEnv* env, ERL_NIF_TERM term)

लौटता है true तो term टपल।

int enif_keep_resource(void* obj)

obj से प्राप्त संसाधन ऑब्जेक्ट का संदर्भ जोड़ता है enif_alloc_resource । ऑब्जेक्ट को नष्ट enif_keep_resource करने enif_release_resource से पहले प्रत्येक कॉल किसी ऑब्जेक्ट के लिए संतुलित होनी चाहिए ।

ERL_NIF_TERM enif_make_atom(ErlNifEnv* env, const char* name)

आईएसओ लैटिन -1 एन्कोडिंग के साथ NULL -terminated C-string से एक परमाणु शब्द बनाता है name । यदि name एक परमाणु (255 वर्ण) के लिए अनुमत अधिकतम लंबाई से अधिक है, तो enif_make_atom आक्रमण होता है enif_make_badarg

ERL_NIF_TERM enif_make_atom_len(ErlNifEnv* env, const char* name, size_t len)

name लंबाई के साथ स्ट्रिंग से एक परमाणु शब्द बनाएं len NULL पात्रों को किसी भी अन्य पात्रों के रूप में माना जाता है। यदि len एक परमाणु (255 वर्ण) के लिए अनुमत अधिकतम लंबाई से अधिक है, तो enif_make_atom आह्वान करता है enif_make_badarg

ERL_NIF_TERM enif_make_badarg(ErlNifEnv* env)

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

से वापसी मूल्य का enif_make_badarg उपयोग केवल उस एनआईएफ से वापसी मूल्य के रूप में किया जा सकता है जिसने इसे (प्रत्यक्ष या अप्रत्यक्ष रूप से) लागू किया है या पास किया जा सकता है enif_is_exception , लेकिन किसी अन्य एनआईएफ एपीआई फ़ंक्शन को नहीं।

यह भी देखें enif_has_pending_exception और enif_raise_exception

ध्यान दें

ERTS 7.0 (Erlang / OTP 18) से enif_make_badarg पहले, एनआईएफ से रिटर्न वैल्यू वापस करना पड़ता था। यह आवश्यकता अब हटा दी गई है क्योंकि एनआईएफ से वापसी मूल्य को अनदेखा कर enif_make_badarg दिया गया है यदि इसे लागू किया गया है।

ERL_NIF_TERM enif_make_binary(ErlNifEnv* env, ErlNifBinary* bin)

से एक द्विआधारी शब्द बनाता है bin । बाइनरी डेटा का कोई भी स्वामित्व निर्मित शब्द में स्थानांतरित bin किया जाता है और इसे केवल एनआईएफ के बाकी कॉल के लिए और फिर जारी किए जाने के लिए केवल पढ़ने के लिए माना जाता है।

ERL_NIF_TERM enif_make_copy(ErlNifEnv* dst_env, ERL_NIF_TERM src_term)

शब्द की एक प्रति बनाता है src_term । कॉपी पर्यावरण में बनाई गई है dst_env । स्रोत शब्द किसी भी वातावरण में स्थित हो सकता है।

ERL_NIF_TERM enif_make_double(ErlNifEnv* env, double d)

एक से एक अस्थायी बिंदु शब्द बनाता है double । यदि तर्क double परिमित नहीं है या NaN है, तो enif_make_double आह्वान करता है enif_make_badarg

int enif_make_existing_atom(ErlNifEnv* env, const char* name, ERL_NIF_TERM* atom, ErlNifCharEncoding encode)

एन्कोडिंग के साथ NULL -terminated C-string से पहले से मौजूद परमाणु का शब्द बनाने की कोशिश करता है । name encode

यदि परमाणु पहले से मौजूद है, तो यह फ़ंक्शन शब्द को *atom वापस संग्रहीत करता है और true अन्यथा false false यदि name परमाणु (255 वर्ण) के लिए अनुमत अधिकतम लंबाई से अधिक है, तो भी रिटर्न ।

int enif_make_existing_atom_len(ErlNifEnv* env, const char* name, size_t len, ERL_NIF_TERM* atom, ErlNifCharEncoding encoding)

name लंबाई len और एन्कोडिंग के साथ स्ट्रिंग से पहले से मौजूद परमाणु का कार्यकाल बनाने की कोशिश करता है encode NULL पात्रों को किसी भी अन्य पात्रों के रूप में माना जाता है।

यदि परमाणु पहले से मौजूद है, तो यह फ़ंक्शन शब्द को *atom वापस संग्रहीत करता है और true अन्यथा false false यदि len परमाणु (255 वर्ण) के लिए अनुमत अधिकतम लंबाई से अधिक है तो भी वापस आ जाता है।

ERL_NIF_TERM enif_make_int(ErlNifEnv* env, int i)

पूर्णांक शब्द बनाता है।

ERL_NIF_TERM enif_make_int64(ErlNifEnv* env, ErlNifSInt64 i)

हस्ताक्षरित 64-बिट पूर्णांक से पूर्णांक शब्द बनाता है।

ERL_NIF_TERM enif_make_list(ErlNifEnv* env, unsigned cnt, ...)

लंबाई की एक साधारण सूची शब्द बनाता है cnt । उम्मीद है cnt (के बाद तर्क की संख्या cnt प्रकार के) ERL_NIF_TERM सूची के तत्वों के रूप।

खाली सूची देता है यदि cnt 0 है।

ERL_NIF_TERM enif_make_list1(ErlNifEnv* env, ERL_NIF_TERM e1) ERL_NIF_TERM enif_make_list2(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2) ERL_NIF_TERM enif_make_list3(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2, ERL_NIF_TERM e3) ERL_NIF_TERM enif_make_list4(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e4) ERL_NIF_TERM enif_make_list5(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e5) ERL_NIF_TERM enif_make_list6(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e6) ERL_NIF_TERM enif_make_list7(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e7) ERL_NIF_TERM enif_make_list8(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e8) ERL_NIF_TERM enif_make_list9(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e9)

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

ERL_NIF_TERM enif_make_list_cell(ErlNifEnv* env, ERL_NIF_TERM head, ERL_NIF_TERM tail)

एक सूची सेल बनाता है [head | tail]

ERL_NIF_TERM enif_make_list_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt)

arr लंबाई की सरणी के तत्वों से युक्त एक सामान्य सूची बनाता है cnt

खाली सूची देता है यदि cnt 0 है।

ERL_NIF_TERM enif_make_long(ErlNifEnv* env, long int i)

से एक पूर्णांक शब्द बनाता है long int

int enif_make_map_put(ErlNifEnv* env, ERL_NIF_TERM map_in, ERL_NIF_TERM key, ERL_NIF_TERM value, ERL_NIF_TERM* map_out)

नक्शे की एक प्रति बनाता है map_in और key साथ सम्मिलित करता है value । यदि key पहले से मौजूद है map_in , तो पुराने संबद्ध मान को बदल दिया जाता है value

सफल होने पर, यह फ़ंक्शन *map_out नए मानचित्र पर सेट होता है और वापस लौटता है true false अगर map_in नक्शा नहीं है तो लौटाता है।

यह map_in शब्द पर्यावरण से संबंधित होना चाहिए env

int enif_make_map_remove(ErlNifEnv* env, ERL_NIF_TERM map_in, ERL_NIF_TERM key, ERL_NIF_TERM* map_out)

नक्शा तो map_in शामिल key है, इस समारोह की एक प्रतिलिपि बनाता map_in में *map_out , और निकालता है key और संबद्ध मूल्य। यदि नक्शा map_in शामिल नहीं है key , *map_out तो सेट किया गया है map_in

true सफलता पर लौटा , या false अगर map_in एक नक्शा नहीं है।

यह map_in शब्द पर्यावरण से संबंधित होना चाहिए env

int enif_make_map_update(ErlNifEnv* env, ERL_NIF_TERM map_in, ERL_NIF_TERM key, ERL_NIF_TERM new_value, ERL_NIF_TERM* map_out)

नक्शे की एक प्रति बनाता है map_in और पुराने संबद्ध मान को बदल देता key है new_value

सफल होने पर, यह फ़ंक्शन *map_out नए मानचित्र पर सेट होता है और वापस लौटता है true false अगर map_in नक्शा नहीं है या नहीं है तो लौटाता है key

यह map_in शब्द पर्यावरण से संबंधित होना चाहिए env

int enif_make_map_from_arrays(ErlNifEnv* env, ERL_NIF_TERM keys[], ERL_NIF_TERM values[], size_t cnt, ERL_NIF_TERM *map_out)

दिए गए कुंजी और मूल्यों से एक नक्शा शब्द बनाता है।

सफल होने पर, यह फ़ंक्शन *map_out नए मानचित्र पर सेट होता है और वापस लौटता है true । रिटर्न false वहाँ किसी भी डुप्लिकेट चाबियाँ हैं।

सभी कुंजियों और मूल्यों से संबंधित होना चाहिए env

unsigned char *enif_make_new_binary(ErlNifEnv* env, size_t size, ERL_NIF_TERM* termp)

आकार size बाइट्स का एक बाइनरी आवंटित करता है और एक मालिकाना शब्द बनाता है। जब तक NIF कॉलिंग न हो तब तक बाइनरी डेटा म्यूट होता है। यह उपयोग किए बिना एक नया बाइनरी बनाने का एक त्वरित तरीका है ErlNifBinary । कमियां यह हैं कि द्विआधारी को NIF कॉल के बीच नहीं रखा जा सकता है और इसे पुनः प्राप्त नहीं किया जा सकता।

कच्चे बाइनरी डेटा को एक पॉइंटर लौटाता है और *termp बाइनरी टर्म पर सेट करता है।

ERL_NIF_TERM enif_make_new_map(ErlNifEnv* env)

खाली नक्शा शब्द बनाता है।

ERL_NIF_TERM enif_make_pid(ErlNifEnv* env, const ErlNifPid* pid)

से एक कठिन शब्द बनाता है *pid

ERL_NIF_TERM enif_make_ref(ErlNifEnv* env)

जैसा कोई संदर्भ बनाता है erlang:make_ref/0

ERL_NIF_TERM enif_make_resource(ErlNifEnv* env, void* obj)

द्वारा प्राप्त स्मृति-प्रबंधित संसाधन ऑब्जेक्ट में एक अपारदर्शी हैंडल बनाता है enif_alloc_resource । कोई स्वामित्व हस्तांतरण नहीं किया जाता है, क्योंकि संसाधन ऑब्जेक्ट को अभी भी जारी करने की आवश्यकता है enif_release_resource । हालाँकि, ध्यान दें कि कॉल enif_release_resource शब्द से प्राप्त करने के तुरंत बाद हो सकता है enif_make_resource , जिस स्थिति में शब्द एकत्र होने पर संसाधन ऑब्जेक्ट को हटा दिया जाता है। अधिक जानकारी के लिए, example of creating and returning a resource object उपयोगकर्ता गाइड में देखें।

ध्यान दें

ERTS 9.0 (OTP-20.0) के बाद से, जब term_to_binary नोड्स के बीच तुलना की जाती है या अनुक्रमित की जाती है, तो संसाधन शर्तों में एक परिभाषित व्यवहार होता है ।

  • दो संसाधन शब्द समान iff की तुलना करेंगे जब वे पास होने पर समान संसाधन ऑब्जेक्ट पॉइंटर प्राप्त करेंगे enif_get_resource

  • एक संसाधन शब्द के साथ क्रमबद्ध किया जा सकता है term_to_binary और बाद में पूरी तरह से फिर से बनाया जा सकता है अगर संसाधन वस्तु अभी भी जीवित है जब binary_to_term कहा जाता है। यदि संसाधन ऑब्जेक्ट को हटा दिया गया है तो एक बासी संसाधन शब्द वापस कर दिया जाएगा binary_to_term enif_get_resource बासी संसाधन शर्तों के लिए गलत वापस आएगा।

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

ERTS 9.0 (OTP-20.0) से पहले, सभी संसाधन शर्तों ने एक दूसरे के बराबर और बायनेरिज़ ( <<>> ) खाली करने के लिए तुलना की थी । यदि सीरियल किया जाता है, तो उन्हें सादे खाली बायनेरिज़ के रूप में फिर से बनाया जाएगा।

ERL_NIF_TERM enif_make_resource_binary(ErlNifEnv* env, void* obj, const void* data, size_t size)

एक द्विआधारी शब्द बनाता है जिसे मेमोरी द्वारा प्रबंधित संसाधन ऑब्जेक्ट द्वारा प्रबंधित obj किया जाता है enif_alloc_resource । दिए गए बाइनरी शब्द में size बाइट्स की ओर इशारा किया गया है data । इस कच्चे बाइनरी डेटा को पठनीय और अपरिवर्तित रखा जाना चाहिए जब तक कि संसाधन का विनाशकर्ता नहीं कहा जाता है। बाइनरी डेटा को संसाधन ऑब्जेक्ट के लिए बाहरी संग्रहीत किया जा सकता है, जिस स्थिति में डेटा को जारी करने के लिए विध्वंसक जिम्मेदार है।

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

जैसा कि enif_make_resource , कोई स्वामित्व हस्तांतरण नहीं किया जाता है। संसाधन को अभी भी जारी करने की आवश्यकता है enif_release_resource

int enif_make_reverse_list(ErlNifEnv* env, ERL_NIF_TERM list_in, ERL_NIF_TERM *list_out)

सेट *list_out सूची के पीछे की सूची पर list_in और रिटर्न true , या रिटर्न false अगर list_in एक सूची नहीं है।

यह फ़ंक्शन केवल छोटी सूचियों पर उपयोग किया जाना है, क्योंकि एक प्रति सूची से बनाई गई है, जो एनआईएफ रिटर्न के बाद तक जारी नहीं की जाती है।

यह list_in शब्द पर्यावरण से संबंधित होना चाहिए env

ERL_NIF_TERM enif_make_string(ErlNifEnv* env, const char* string, ErlNifCharEncoding encoding)

एन्कोडिंग के साथ NULL -terminated स्ट्रिंग के वर्णों वाली सूची बनाता है । string encode

ERL_NIF_TERM enif_make_string_len(ErlNifEnv* env, const char* string, size_t len, ErlNifCharEncoding encoding)

एक सूची बनाता है जिसमें string लंबाई len और एन्कोडिंग के साथ स्ट्रिंग के वर्ण होते हैं encode NULL पात्रों को किसी भी अन्य पात्रों के रूप में माना जाता है।

ERL_NIF_TERM enif_make_sub_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term, size_t pos, size_t size)

बाइट्स की एक उप-श्रृंखला बनाता है bin_term , जो बाइट्स की pos लंबाई के साथ शून्य-आधारित स्थिति पर शुरू होता है size bin_term बाइनरी या बिटस्ट्रिंग होना चाहिए। pos+size में कम या पूरे बाइट्स की संख्या के बराबर होना चाहिए bin_term

ERL_NIF_TERM enif_make_tuple(ErlNifEnv* env, unsigned cnt, ...)

तुच्छ शब्द का निर्माण करता है cnt । उम्मीद है cnt (के बाद तर्क की संख्या cnt प्रकार के) ERL_NIF_TERM टपल के तत्वों के रूप।

ERL_NIF_TERM enif_make_tuple1(ErlNifEnv* env, ERL_NIF_TERM e1) ERL_NIF_TERM enif_make_tuple2(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2) ERL_NIF_TERM enif_make_tuple3(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2, ERL_NIF_TERM e3) ERL_NIF_TERM enif_make_tuple4(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e4) ERL_NIF_TERM enif_make_tuple5(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e5) ERL_NIF_TERM enif_make_tuple6(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e6) ERL_NIF_TERM enif_make_tuple7(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e7) ERL_NIF_TERM enif_make_tuple8(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e8) ERL_NIF_TERM enif_make_tuple9(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e9)

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

ERL_NIF_TERM enif_make_tuple_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt)

arr लंबाई के सरणी के तत्वों वाले एक टपल बनाता है cnt

ERL_NIF_TERM enif_make_uint(ErlNifEnv* env, unsigned int i)

से एक पूर्णांक शब्द बनाता है unsigned int

ERL_NIF_TERM enif_make_uint64(ErlNifEnv* env, ErlNifUInt64 i)

अहस्ताक्षरित 64-बिट पूर्णांक से पूर्णांक शब्द बनाता है।

ERL_NIF_TERM enif_make_ulong(ErlNifEnv* env, unsigned long i)

से एक पूर्णांक शब्द बनाता है unsigned long int

ERL_NIF_TERM enif_make_unique_integer(ErlNifEnv *env, ErlNifUniqueInteger properties)

द्वारा निर्दिष्ट के रूप में एक ही गुण के साथ एक अद्वितीय पूर्णांक देता है erlang:unique_integer/1

env में पूर्णांक बनाने के लिए पर्यावरण है।

ERL_NIF_UNIQUE_POSITIVE और ERL_NIF_UNIQUE_MONOTONIC पूर्णांक के गुणों को बदलने के लिए दूसरे तर्क के रूप में पारित किया जा सकता है। उन्हें OR द्वारा संयोजित किया जा सकता है: दो मानों को एक साथ जोड़ते हैं।

यह भी देखें ErlNifUniqueInteger

int enif_map_iterator_create(ErlNifEnv *env, ERL_NIF_TERM map, ErlNifMapIterator *iter, ErlNifMapIteratorEntry entry)

map द्वारा इंगित संरचना को आरंम्भ करके मानचित्र के लिए एक पुनरावृत्ति बनाता है iter । तर्क इट्रेटर entry की शुरुआत की स्थिति निर्धारित करता है: ERL_NIF_MAP_ITERATOR_FIRST या ERL_NIF_MAP_ITERATOR_LAST

true यदि map नक्शा नहीं है , तो सफलता, या झूठ पर रिटर्न ।

एक मैप इटेटर केवल पर्यावरण के जीवनकाल के दौरान उपयोगी होता है env , जिसका map संबंध है। इटैलर को कॉल करके नष्ट किया जाना चाहिए enif_map_iterator_destroy :

ERL_NIF_TERM key, value;
ErlNifMapIterator iter;
enif_map_iterator_create(env, my_map, &iter, ERL_NIF_MAP_ITERATOR_FIRST);

while (enif_map_iterator_get_pair(env, &iter, &key, &value)) {
    do_something(key,value);
    enif_map_iterator_next(env, &iter);
}
enif_map_iterator_destroy(env, &iter);
ध्यान दें

मानचित्र के मुख्य-मूल्य वाले युग्मों में कोई परिभाषित क्रम नहीं है। एकमात्र गारंटी यह है कि नक्शे के अंतर्गत आने वाले पर्यावरण के जीवनकाल के दौरान एकल मानचित्र उदाहरण का पुनरावृत्ति क्रम संरक्षित है।

void enif_map_iterator_destroy(ErlNifEnv *env, ErlNifMapIterator *iter)

द्वारा बनाए गए मैप इटेटर को नष्ट कर देता है enif_map_iterator_create

int enif_map_iterator_get_pair(ErlNifEnv *env, ErlNifMapIterator *iter, ERL_NIF_TERM *key, ERL_NIF_TERM *value)

वर्तमान मानचित्र पुनरावृत्ति स्थिति में कुंजी और मूल्य की शर्तें प्राप्त करता है।

सफलता पर, सेट *key और *value और रिटर्न true । रिटर्न false अगर इट्रेटर सिर पर (पहली प्रविष्टि से पहले) या पूंछ (अंतिम प्रविष्टि से परे) पर स्थित है।

int enif_map_iterator_is_head(ErlNifEnv *env, ErlNifMapIterator *iter)

true यदि रिटर्न इट्रेटर iter पहली प्रविष्टि से पहले तैनात है।

int enif_map_iterator_is_tail(ErlNifEnv *env, ErlNifMapIterator *iter)

true यदि iter अंतिम प्रविष्टि के बाद मैप इटेटर तैनात है तो वापस लौटाता है।

int enif_map_iterator_next(ErlNifEnv *env, ErlNifMapIterator *iter)

अगले मुख्य-मूल्य प्रविष्टि को इंगित करने के लिए इंक्रीमेंट मैप इटरेटर।

true यदि इट्रेटर अब एक मान्य कुंजी-मूल्य प्रविष्टि पर स्थित है, या false यदि पुनरावर्तक को टेल (अंतिम प्रविष्टि से परे) पर पोस्ट किया गया है , तो वापस लौटाता है ।

int enif_map_iterator_prev(ErlNifEnv *env, ErlNifMapIterator *iter)

पिछले मुख्य-मूल्य प्रविष्टि को इंगित करने के लिए Decrements मैप इटरेटर।

true यदि इट्रेटर अब एक मान्य कुंजी-मूल्य प्रविष्टि पर स्थित है, या false यदि इटिटर को हेड (पहले प्रवेश से पहले) पर स्थित है, तो वापस लौटाता है ।

int enif_monitor_process(ErlNifEnv* env, void* obj, const ErlNifPid* target_pid, ErlNifMonitor* mon)

एक संसाधन से एक प्रक्रिया की निगरानी शुरू करता है। जब एक प्रक्रिया की निगरानी की जाती है, down तो संसाधन प्रकार से जुड़े कॉलबैक को कॉल करने की प्रक्रिया में एक परिणाम से बाहर निकलता है ।

obj निगरानी रखने के लिए तर्क संसाधन का सूचक है और *target_pid स्थानीय प्रक्रिया की निगरानी करने के लिए पहचान करता है।

यदि mon ऐसा नहीं है NULL , तो एक सफल कॉल ErlNifMonitor द्वारा बताई गई संरचना में मॉनिटर की पहचान को संग्रहीत करता है mon । इस पहचानकर्ता का उपयोग बाद में हटाने enif_demonitor_process या इसके साथ तुलना करने के लिए मॉनिटर को संदर्भित करने के लिए किया जाता है enif_compare_monitors । जब यह ट्रिगर हो जाता है या जब संसाधन समाप्त हो जाता है तो एक मॉनिटर स्वचालित रूप से हटा दिया जाता है।

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

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

ErlNifTime enif_monotonic_time(ErlNifTimeUnit time_unit)

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

time_unit लौटाया गया मान का समय इकाई है।

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

यह भी देखें ErlNifTime और ErlNifTimeUnit

ErlNifMutex *enif_mutex_create(char *name)

के रूप में ही erl_drv_mutex_create

void enif_mutex_destroy(ErlNifMutex *mtx)

के रूप में ही erl_drv_mutex_destroy

void enif_mutex_lock(ErlNifMutex *mtx)

के रूप में ही erl_drv_mutex_lock

char*enif_mutex_name(ErlNifMutex* mtx)

के रूप में ही erl_drv_mutex_name

int enif_mutex_trylock(ErlNifMutex *mtx)

के रूप में ही erl_drv_mutex_trylock

void enif_mutex_unlock(ErlNifMutex *mtx)

के रूप में ही erl_drv_mutex_unlock

ERL_NIF_TERM enif_now_time(ErlNifEnv *env)

एक रिटर्न erlang:now() समय स्टाम्प।

इस फ़ंक्शन को पदावनत किया जाता है।

ErlNifResourceType *enif_open_resource_type(ErlNifEnv* env, const char* module_str, const char* name, ErlNifResourceDtor* dtor, ErlNifResourceFlags flags, ErlNifResourceFlags* tried)

स्ट्रिंग द्वारा पहचाने गए संसाधन प्रकार को बनाता है या लेता है name और इसे इंगित किए गए विनाशकर्ता फ़ंक्शन देता है dtor । तर्क flags में निम्नलिखित मूल्य हो सकते हैं:

ERL_NIF_RT_CREATE
एक नया संसाधन प्रकार बनाता है जो पहले से मौजूद नहीं है।
ERL_NIF_RT_TAKEOVER
एक मौजूदा संसाधन प्रकार को खोलता है और इसके सभी उदाहरणों पर स्वामित्व रखता है। आपूर्ति किए गए विनाशकर्ता dtor को मौजूदा उदाहरणों के लिए कहा जाता है और नए उदाहरणों को अभी तक कॉलिंग एनआईएफ लाइब्रेरी द्वारा नहीं बनाया गया है।

दो ध्वज मूल्यों को बिटवाइज़ या के साथ जोड़ा जा सकता है। संसाधन प्रकार का नाम कॉलिंग मॉड्यूल के लिए स्थानीय है। तर्क module_str का उपयोग नहीं किया गया है (अभी तक) और होना चाहिए NULL dtor हो सकता है NULL अगर कोई विध्वंसक की जरूरत न हो।

सफलता पर, समारोह संसाधन प्रकार के लिए सूचक वापस आती है और *tried करने के लिए या तो सेट कर दिया जाता ERL_NIF_RT_CREATE या ERL_NIF_RT_TAKEOVER इंगित करने के लिए क्या किया गया था। विफलता पर, रिटर्न NULL और सेट *tried पर flags । इसे सेट tried करने की अनुमति है NULL

सूचना जो enif_open_resource_type केवल दो कॉलबैक में कॉल करने की अनुमति है load और upgrade

यह भी देखें enif_open_resource_type_x

ErlNifResourceType *enif_open_resource_type_x(ErlNifEnv* env, const char* name, const ErlNifResourceTypeInit* init, ErlNifResourceFlags flags, ErlNifResourceFlags* tried)

के रूप में ही enif_open_resource_type छोड़कर यह संसाधन प्रकार है कि के साथ एक साथ इस्तेमाल कर रहे हैं के लिए अतिरिक्त कॉलबैक कार्यों को स्वीकार करता है enif_select और enif_monitor_process

तर्क init एक ErlNifResourceTypeInit संरचना का सूचक है जिसमें संसाधन प्रकार के लिए विनाशकारी, डाउन और स्टॉप कॉलबैक के लिए फ़ंक्शन पॉइंटर्स होते हैं।

int enif_port_command(ErlNifEnv* env, const ErlNifPort* to_port, ErlNifEnv *msg_env, ERL_NIF_TERM msg)

के रूप में काम करता है erlang:port_command/2 , सिवाय इसके कि यह हमेशा पूरी तरह से अतुल्यकालिक है।

env
कॉलिंग प्रक्रिया का वातावरण। नहीं होना चाहिए NULL
*to_port
प्राप्त पोर्ट की पोर्ट आईडी। पोर्ट आईडी स्थानीय नोड पर एक पोर्ट को संदर्भित करना है।
msg_env
संदेश शब्द का वातावरण। एक प्रक्रिया स्वतंत्र पर्यावरण के साथ आवंटित किया जा सकता है enif_alloc_env या NULL
msg
भेजने के लिए संदेश शब्द। पेलोड पर जैसी सीमाएँ लागू होती हैं erlang:port_command/2

एक का उपयोग msg_env की NULL एक अनुकूलन है, जो संगठनों को एक साथ कहता है करने के लिए enif_alloc_env , enif_make_copy , enif_port_command , और enif_free_env एक कॉल में। यह अनुकूलन केवल तभी उपयोगी होता है जब अधिकांश शर्तों को कॉपी किया जाना env हो msg_env

true यदि आदेश सफलतापूर्वक भेजा जाता है, तो लौटाता है । false उदाहरण के लिए, कमांड विफल होने पर लौटाता है :

  • *to_port स्थानीय पोर्ट को संदर्भित नहीं करता है।
  • वर्तमान में निष्पादित प्रक्रिया (जो कि प्रेषक है) जीवित नहीं है।
  • msg अमान्य है।

यह भी देखें enif_get_local_port

void *enif_priv_data(ErlNifEnv* env)

उस निजी डेटा को सूचक लौटाता है जिसे load या द्वारा सेट किया गया था upgrade

ERL_NIF_TERM enif_raise_exception(ErlNifEnv* env, ERL_NIF_TERM reason)

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

से वापसी मूल्य का enif_raise_exception उपयोग केवल उस एनआईएफ से वापसी मूल्य के रूप में किया जा सकता है जिसने इसे (प्रत्यक्ष या अप्रत्यक्ष रूप से) लागू किया है या पास किया जा सकता है enif_is_exception , लेकिन किसी अन्य एनआईएफ एपीआई फ़ंक्शन को नहीं।

यह भी देखें enif_has_pending_exception और enif_make_badarg

void *enif_realloc(void* ptr, size_t size)

द्वारा आबंटित स्मृति से पुनर enif_alloc को size बाइट्स।

NULL यदि पुनः प्राप्ति विफल हो जाती है तो वापस लौटता है।

लौटे हुए पॉइंटर को किसी भी अंतर्निहित प्रकार के लिए उपयुक्त रूप से संरेखित किया गया है जो आवंटित मेमोरी में फिट होता है।

int enif_realloc_binary(ErlNifBinary* bin, size_t size)

एक बाइनरी का आकार बदलता है bin । स्रोत बाइनरी केवल-पढ़ा जा सकता है, जिस स्थिति में इसे अछूता छोड़ दिया जाता है और एक परस्पर प्रतिलिपि आवंटित और आवंटित की जाती है *bin

true सफलता पर रिटर्न , या false यदि स्मृति आवंटन विफल रहा।

void enif_release_binary(ErlNifBinary* bin)

से प्राप्त एक बाइनरी को रिहा करता है enif_alloc_binary

void enif_release_resource(void* obj)

obj से प्राप्त संसाधन ऑब्जेक्ट का संदर्भ निकालता है enif_alloc_resource । अंतिम संदर्भ हटाए जाने पर संसाधन ऑब्जेक्ट को नष्ट कर दिया जाता है। प्रत्येक कॉल के enif_release_resource लिए enif_alloc_resource या पिछले कॉल के अनुरूप होना चाहिए enif_keep_resource । द्वारा किए गए संदर्भ enif_make_resource केवल कचरा कलेक्टर द्वारा ही निकाले जा सकते हैं।

ErlNifRWLock *enif_rwlock_create(char *name)

के रूप में ही erl_drv_rwlock_create

void enif_rwlock_destroy(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_destroy

char*enif_rwlock_name(ErlNifRWLock* rwlck)

के रूप में ही erl_drv_rwlock_name

void enif_rwlock_rlock(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_rlock

void enif_rwlock_runlock(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_runlock

void enif_rwlock_rwlock(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_rwlock

void enif_rwlock_rwunlock(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_rwunlock

int enif_rwlock_tryrlock(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_tryrlock

int enif_rwlock_tryrwlock(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_tryrwlock

ERL_NIF_TERM enif_schedule_nif(ErlNifEnv* env, const char* fun_name, int flags, ERL_NIF_TERM (*fp)(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]), int argc, const ERL_NIF_TERM argv[])

अनुसूचियां fp निष्पादित करने के लिए एनआईएफ । यह फ़ंक्शन एक एप्लिकेशन को कई नियमित एनआईएफ कॉल में लंबे समय तक चलने वाले काम को तोड़ने या dirty NIF गंदे शेड्यूलर थ्रेड पर निष्पादित करने की अनुमति देता है ।

fun_name

NIF के लिए एक नाम प्रदान करता है जो निष्पादन के लिए निर्धारित है। यदि इसे एक परमाणु में परिवर्तित नहीं किया जा सकता है, तो enif_schedule_nif एक badarg अपवाद देता है।

flags

0 एक नियमित एनआईएफ के लिए निर्धारित किया जाना चाहिए । यदि एम्यूलेटर को गंदे शेड्यूलर समर्थन सक्षम के साथ बनाया गया था, flags तो या ERL_NIF_DIRTY_JOB_CPU_BOUND तो यह निर्धारित किया जा सकता है कि क्या नौकरी सीपीयू-बाउंड होने की उम्मीद है, या ERL_NIF_DIRTY_JOB_IO_BOUND उन नौकरियों के लिए जो I / O-बाध्य होंगे। यदि गंदे शेड्यूलर थ्रेड्स एमुलेटर में उपलब्ध नहीं हैं, तो इस तरह के काम के परिणाम को शेड्यूल करने का प्रयास notsup अपवाद है।

argc तथा argv

क्या मूल को कॉलिंग NIF में पारित किया जा सकता है, या कॉलिंग NIF द्वारा बनाए गए मान हो सकते हैं।

कॉलिंग NIF enif_schedule_nif को अपने स्वयं के रिटर्न मान के रूप में वापसी मूल्य का उपयोग करना चाहिए ।

ज्ञात हो कि enif_schedule_nif , जैसा कि इसके नाम का तात्पर्य है, भविष्य के निष्पादन के लिए केवल एनआईएफ को निर्धारित करता है। कॉलिंग NIF, निष्पादित करने और लौटने के लिए निर्धारित NIF के इंतजार को अवरुद्ध नहीं करता है। इसका मतलब यह है कि कॉलिंग NIF अनुसूचित NIF रिटर्न मान प्राप्त करने और आगे के संचालन के लिए इसका उपयोग करने की उम्मीद नहीं कर सकता है।

int enif_select(ErlNifEnv* env, ErlNifEvent event, enum ErlNifSelectFlags mode, void* obj, const ErlNifPid* pid, ERL_NIF_TERM ref)

इस फ़ंक्शन का उपयोग अतुल्यकालिक सूचनाओं को प्राप्त करने के लिए किया जा सकता है जब ओएस-विशिष्ट ईवेंट ऑब्जेक्ट या तो पढ़ने या लिखने के संचालन के लिए तैयार हो जाते हैं।

तर्क event घटना वस्तु की पहचान करता है। यूनिक्स प्रणालियों पर, कार्यों select / poll का उपयोग किया जाता है। ईवेंट ऑब्जेक्ट सॉकेट, पाइप या अन्य फ़ाइल डिस्क्रिप्टर ऑब्जेक्ट होना चाहिए जो select / poll उपयोग कर सकता है।

तर्क mode घटनाओं के प्रकार का वर्णन करने के लिए प्रतीक्षा करता है। यह ERL_NIF_SELECT_READ , ERL_NIF_SELECT_WRITE या दोनों के लिए प्रतीक्षा करने के लिए एक बिटवाइज़ या संयोजन हो सकता है। यह वह भी हो सकता है ERL_NIF_SELECT_STOP जिसका वर्णन नीचे किया गया है। जब कोई पढ़ने या लिखने की घटना शुरू होती है, तो इस तरह से एक अधिसूचना संदेश द्वारा पहचानी गई प्रक्रिया को भेजा जाता है pid :

{select, Obj, Ref, ready_input | ready_output}

ready_input या ready_output इंगित करता है कि ईवेंट ऑब्जेक्ट पढ़ने या लिखने के लिए तैयार है या नहीं।

तर्क कॉलिंग प्रक्रिया को इंगित करने के लिए pid हो सकता NULL है।

तर्क obj एक संसाधन से प्राप्त वस्तु है enif_alloc_resource । संसाधन ऑब्जेक्ट का उद्देश्य इवेंट ऑब्जेक्ट के एक कंटेनर के रूप में अपने राज्य और जीवनकाल का प्रबंधन करने के लिए है। सूचना संदेश के रूप में संसाधन का एक हैंडल प्राप्त होता है Obj

तर्क ref या तो एक संदर्भ होना चाहिए या erlang:make_ref/0 परमाणु से प्राप्त किया जाना चाहिए undefined । इसे Ref नोटिफिकेशन में पास किया जाएगा । यदि receive अधिसूचना के लिए प्रतीक्षा करने के लिए एक चयनात्मक बयान का उपयोग किया जाता है, तो receive एक रनटाइम ऑप्टिमाइज़ेशन का उपयोग करने से ठीक पहले बनाया गया एक संदर्भ जो कतार में सभी पहले प्राप्त संदेशों को बायपास करता है।

सूचनाएं केवल एक-शॉट हैं। एक ही प्रकार (आगे पढ़ें या लिखें) की और enif_select सूचनाएं प्राप्त करने के लिए, प्रत्येक सूचना प्राप्त करने के बाद बार-बार कॉल करना होगा।

का प्रयोग करें ERL_NIF_SELECT_STOP के रूप में mode आदेश सुरक्षित रूप से एक घटना उद्देश्य यह है कि करने के लिए पारित किया गया है बंद करने के लिए में enif_select । इवेंट ऑब्जेक्ट को बंद करने के लिए सुरक्षित होने पर stop संसाधन का कॉलबैक obj कहा जाएगा। ईवेंट ऑब्जेक्ट्स को बंद करने के इस सुरक्षित तरीके का उपयोग किया जाना चाहिए, भले ही सभी सूचनाएं प्राप्त हुई हों और आगे कॉल न की enif_select गई हो।

enif_select विशिष्ट OS के लिए पहला कॉल event इवेंट ऑब्जेक्ट और युक्त संसाधन के बीच एक संबंध स्थापित करेगा। सभी के लिए बाद में कॉल event तर्क के रूप में अपने संसाधन युक्त होना चाहिए obj । इस संबंध को तब भंग कर enif_select दिया जाता है जब इसके साथ कॉल किया mode जाता है ERL_NIF_SELECT_STOP और संबंधित stop कॉलबैक वापस आ गया है। एक संसाधन में कई ईवेंट ऑब्जेक्ट हो सकते हैं लेकिन एक ईवेंट ऑब्जेक्ट केवल एक संसाधन के भीतर ही हो सकता है। एक संसाधन तब तक नष्ट नहीं किया जाएगा जब तक कि उसके सभी निहित संबंध भंग न हो जाएं।

ध्यान दें

इरलांग प्रक्रियाओं को विफल करने का पता लगाने के लिए enif_monitor_process एक साथ उपयोग करें enif_select और संसाधनों के स्थायी रिसाव और उनके निहित ओएस घटना वस्तुओं को पैदा करने से रोकें।

सफलता पर एक गैर-नकारात्मक मान लौटाता है, जहां निम्नलिखित बिट्स सेट किए जा सकते हैं:

ERL_NIF_SELECT_STOP_CALLED
स्टॉप कॉलबैक द्वारा सीधे कॉल किया गया था enif_select
ERL_NIF_SELECT_STOP_SCHEDULED
स्टॉप कॉलबैक को किसी अन्य थ्रेड पर या बाद में इस थ्रेड द्वारा चलाने के लिए निर्धारित किया गया था।

यदि कॉल विफल हो गया तो एक नकारात्मक मान लौटाता है जहां निम्नलिखित बिट्स सेट किए जा सकते हैं:

ERL_NIF_SELECT_INVALID_EVENT
तर्क event एक मान्य OS ईवेंट ऑब्जेक्ट नहीं है।
ERL_NIF_SELECT_FAILED
ईवेंट ऑब्जेक्ट को पोल सेट में जोड़ने के लिए सिस्टम कॉल विफल रहा।
ध्यान दें

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

उदाहरण:

retval = enif_select(env, fd, ERL_NIF_SELECT_STOP, resource, ref);
if (retval < 0) {
    /* handle error */
}
/* Success! */
if (retval & ERL_NIF_SELECT_STOP_CALLED) {
    /* ... */
}

ErlNifPid *enif_self(ErlNifEnv* caller_env, ErlNifPid* pid)

कॉलिंग प्रक्रिया का प्रतिनिधित्व करने के लिए ErlNifPid चर पर प्रारंभिक *pid

रिटर्न pid अगर सफल, या शून्य अगर caller_env एक नहीं है ErlNifEnv

int enif_send(ErlNifEnv* env, ErlNifPid* to_pid, ErlNifEnv* msg_env, ERL_NIF_TERM msg)

एक प्रक्रिया के लिए एक संदेश भेजता है।

env
कॉलिंग प्रक्रिया का वातावरण। NULL निर्मित धागे से कॉल करने पर ही होना चाहिए ।
*to_pid
प्राप्त करने की प्रक्रिया की पिड। Pid को स्थानीय नोड पर एक प्रक्रिया को संदर्भित करना है।
msg_env
संदेश शब्द का वातावरण। enif_alloc_env NULL या NULL के साथ आवंटित एक प्रक्रिया-स्वतंत्र वातावरण होना चाहिए ।
msg
भेजने के लिए संदेश शब्द।

true यदि संदेश सफलतापूर्वक भेजा जाता है तो वापस लौटता है । false यदि रिटर्न भेजने में विफल रहता है, तो वह है:

  • *to_pid एक जीवित स्थानीय प्रक्रिया का उल्लेख नहीं करता है।
  • वर्तमान में निष्पादित प्रक्रिया (जो कि प्रेषक है) जीवित नहीं है।

एक सफल कॉल द्वारा msg_env इसकी सभी शर्तों (सहित msg ) के साथ संदेश का वातावरण अमान्य है enif_send । पर्यावरण को या तो फिर से मुक्त करने enif_free_env के लिए मुक्त किया जाना है enif_clear_env

यदि msg_env सेट किया गया है NULL , तो msg शब्द की प्रतिलिपि बनाई गई है और मूल शब्द और उसका वातावरण कॉल के बाद भी मान्य है।

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

ध्यान दें

msg_env जैसा NULL कि पासिंग केवल ERTS 8.0 (Erlang / OTP 19) से समर्थित है।

unsigned enif_sizeof_resource(void* obj)

obj द्वारा प्राप्त संसाधन ऑब्जेक्ट की बाइट आकार प्राप्त करता है enif_alloc_resource

int enif_snprintf(char *str, size_t size, const char *format, ...)

इसी तरह snprintf लेकिन यह प्रारूप स्ट्रिंग भी स्वीकार करता है "%T" , जो Erlang शब्दों को प्रारूपित करता है ।

यह फ़ंक्शन मूल रूप से डीबगिंग उद्देश्य के लिए इरादा था। इसके साथ बहुत बड़ी शर्तें मुद्रित करने की अनुशंसा नहीं की जाती है %T । समारोह errno सफल होने पर भी बदल सकता है ।

void enif_system_info(ErlNifSysInfo *sys_info_ptr, size_t size)

के रूप में ही driver_system_info

int enif_term_to_binary(ErlNifEnv *env, ERL_NIF_TERM term, ErlNifBinary *bin)

एर्लांग बाहरी शब्द प्रारूप के अनुसार enif_alloc_binary एन्कोडिंग के परिणाम के साथ एक नया बाइनरी आवंटित term करता है।

true सफलता पर रिटर्न , या false यदि आवंटन विफल रहता है।

यह भी देखें erlang:term_to_binary/1 और enif_binary_to_term

int enif_thread_create(char *name,ErlNifTid *tid,void * (*func)(void *),void *args,ErlNifThreadOpts *opts)

के रूप में ही erl_drv_thread_create

void enif_thread_exit(void *resp)

के रूप में ही erl_drv_thread_exit

int enif_thread_join(ErlNifTid, void **respp)

के रूप में ही erl_drv_thread_join

char*enif_thread_name(ErlNifTid tid)

के रूप में ही erl_drv_thread_name

ErlNifThreadOpts *enif_thread_opts_create(char *name)

के रूप में ही erl_drv_thread_opts_create

void enif_thread_opts_destroy(ErlNifThreadOpts *opts)

के रूप में ही erl_drv_thread_opts_destroy

ErlNifTid enif_thread_self(void)

के रूप में ही erl_drv_thread_self

int enif_thread_type(void)

वर्तमान में निष्पादित थ्रेड के प्रकार का निर्धारण करें। एक सकारात्मक मान एक शेड्यूलर थ्रेड को इंगित करता है जबकि एक नकारात्मक मान या शून्य दूसरे प्रकार के थ्रेड को इंगित करता है। वर्तमान में निम्नलिखित विशिष्ट प्रकार मौजूद हैं (जिन्हें भविष्य में बढ़ाया जा सकता है):

ERL_NIF_THR_UNDEFINED

अपरिभाषित धागा जो एक अनुसूचक धागा नहीं है।

ERL_NIF_THR_NORMAL_SCHEDULER

एक सामान्य अनुसूचक धागा।

ERL_NIF_THR_DIRTY_CPU_SCHEDULER

एक गंदा सीपीयू अनुसूचक धागा।

ERL_NIF_THR_DIRTY_IO_SCHEDULER

एक गंदा I / O अनुसूचक धागा।

ErlNifTime enif_time_offset(ErlNifTimeUnit time_unit)

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

time_unit लौटाया गया मान का समय इकाई है।

रिटर्न ERL_NIF_TIME_ERROR गलत समय इकाई तर्क के साथ कॉल या एक धागा है कि एक अनुसूचक धागा नहीं है से कहा जाता है, तो यदि।

यह भी देखें ErlNifTime और ErlNifTimeUnit

void *enif_tsd_get(ErlNifTSDKey key)

के रूप में ही erl_drv_tsd_get

int enif_tsd_key_create(char *name, ErlNifTSDKey *key)

के रूप में ही erl_drv_tsd_key_create

void enif_tsd_key_destroy(ErlNifTSDKey key)

के रूप में ही erl_drv_tsd_key_destroy

void enif_tsd_set(ErlNifTSDKey key, void *data)

के रूप में ही erl_drv_tsd_set

int enif_vfprintf(FILE *stream, const char *format, va_list ap)

समतुल्य enif_fprintf सिवाय इसके कि एक के साथ अपने बुलाया va_list तर्क के परिवर्तनशील के बजाय।

int enif_vsnprintf(char *str, size_t size, const char *format, va_list ap)

समतुल्य enif_snprintf सिवाय इसके कि एक के साथ अपने बुलाया va_list तर्क के परिवर्तनशील के बजाय।

int enif_whereis_pid(ErlNifEnv *env, ERL_NIF_TERM name, ErlNifPid *pid)

एक प्रक्रिया को उसके पंजीकृत नाम से देखता है।

env
कॉलिंग प्रक्रिया का वातावरण। NULL निर्मित धागे से कॉल करने पर ही होना चाहिए ।
name
परमाणु के रूप में एक पंजीकृत प्रक्रिया का नाम।
*pid
ErlNifPid जो में हल प्रक्रिया आईडी संग्रहित है।

सफलता पर, *pid स्थानीय प्रक्रिया के साथ पंजीकृत name और रिटर्न के लिए सेट true । यदि name एक पंजीकृत प्रक्रिया नहीं है, या एक परमाणु नहीं है, false तो वापस आ गया है और *pid अपरिवर्तित है।

के रूप में काम करता है erlang:whereis/1 , लेकिन प्रक्रियाओं तक ही सीमित है। enif_whereis_port पंजीकृत बंदरगाहों को हल करने के लिए देखें ।

int enif_whereis_port(ErlNifEnv *env, ERL_NIF_TERM name, ErlNifPort *port)

इसके पंजीकृत नाम से एक बंदरगाह दिखता है।

env
कॉलिंग प्रक्रिया का वातावरण। NULL निर्मित धागे से कॉल करने पर ही होना चाहिए ।
name
परमाणु के रूप में पंजीकृत बंदरगाह का नाम।
*port
ErlNifPort जो में हल बंदरगाह आईडी संग्रहित है।

सफलता के साथ, *port पोर्ट के साथ पंजीकृत name और रिटर्न के लिए सेट true । यदि name एक पंजीकृत बंदरगाह नहीं है, या एक परमाणु नहीं है, false तो वापस लौटा दिया जाता है और *port अपरिवर्तित होता है।

के रूप में काम करता है erlang:whereis/1 , लेकिन बंदरगाहों तक ही सीमित है। enif_whereis_pid पंजीकृत प्रक्रियाओं को हल करने के लिए देखें ।

यह भी देखें

erlang:load_nif/2

Original text