erlang NIF部分接口实现（五）复用driver功能的接口

dreamxyp

NIF除了自身提供的功能外，还封装了一系列driver的功能，这些功能与操作系统平台紧密相关，主要包括：

系统信息， 操作系统线程及线程私有资源 ，条件变量、信号量、读写锁等，这些功能本身与erlang的进程体系无关，本身也是线程安全的，因此可以直接复用到NIF中，统一NIF的接口。

此处简单的分析一个操作系统线程创建的接口，其余的类似。

1. int enif_thread_create(char *name, ErlNifTid *tid, void* (*func)(void *),
   
2.                        void *args, ErlNifThreadOpts *opts) {
   
3.     return erl_drv_thread_create(name,tid,func,args,(ErlDrvThreadOpts*)opts);
   
4. }
   
5. enif_thread_create直接调用了对应的driver接口erl_drv_thread_create，其它复用driver功能的接口也类似。
   
6. int
   
7. erl_drv_thread_create(char *name,
   
8.                       ErlDrvTid *tid,
   
9.                       void* (*func)(void*),
   
10.                       void* arg,
    
11.                       ErlDrvThreadOpts *opts)
    
12. {
    
13. #ifdef USE_THREADS
    
14.     int res;
    
15.     struct ErlDrvTid_ *dtid;
    
16.     ethr_thr_opts ethr_opts;
    
17.     ethr_thr_opts *use_opts;
    
18. 
    
19.     if (!opts)
    
20.         use_opts = NULL;
    
21.     else {
    
22.         sys_memcpy((void *) ðr_opts,
    
23.                    (void *) &def_ethr_opts,
    
24.                    sizeof(ethr_thr_opts));
    
25.         ethr_opts.suggested_stack_size = opts->suggested_stack_size;
    
26.         use_opts = ðr_opts;
    
27.     }
    
28. 
    
29.     dtid = erts_alloc_fnf(ERTS_ALC_T_DRV_TID,
    
30.                           (sizeof(struct ErlDrvTid_)
    
31.                            + (name ? sys_strlen(name) + 1 : 0)));
    
32.     /* 分配一个ErlDrvTid_结构，保存线程描述符 */
    
33.     /*
    
34.         struct ErlDrvTid_ {
    
35.             ethr_tid tid;
    
36.             void* (*func)(void*);
    
37.             void* arg;
    
38.             int drv_thr;
    
39.             Uint tsd_len;
    
40.             void **tsd;
    
41.             char *name;
    
42.         };
    
43.      */
    
44. 
    
45.     if (!dtid)
    
46.         return ENOMEM;
    
47. 
    
48.     dtid->drv_thr = 1;
    
49.     dtid->func = func;
    
50.     dtid->arg = arg;
    
51.     dtid->tsd = NULL;
    
52.     dtid->tsd_len = 0;
    
53. 
    
54.     /* 填充线程描述符，func为线程执行入口点，arg为其参数，tsd为线程私有数据结构，可以保存线程私有数据，与线程紧密相关 */
    
55. 
    
56.     if (!name)
    
57.         dtid->name = no_name;
    
58.     else {
    
59.         dtid->name = ((char *) dtid) + sizeof(struct ErlDrvTid_);
    
60.         sys_strcpy(dtid->name, name);
    
61.     }
    
62.     res = ethr_thr_create(&dtid->tid, erl_drv_thread_wrapper, dtid, use_opts);
    
63. 
    
64.     /* 创建一个操作系统线程，该线程并不直接以用户提供的函数为入口点，而是提供了一层外覆函数， 外覆 函数为erl_drv_thread_wrapper */
    
65. 
    
66.     if (res != 0) {
    
67.         erts_free(ERTS_ALC_T_DRV_TID, dtid);
    
68.         return res;
    
69.     }
    
70. 
    
71.     *tid = (ErlDrvTid) dtid;
    
72. 
    
73.     /* 返回创建的线程描述符 */
    
74. 
    
75.     return 0;
    
76. #else
    
77.     return ENOTSUP;
    
78. #endif
    
79. }
    
80. int ethr_thr_create(ethr_tid *tid, void * (*func)(void *), void *arg, ethr_thr_opts *opts)
    
81. {
    
82.     ethr_thr_wrap_data__ twd;
    
83.     pthread_attr_t attr;
    
84.     int res, dres;
    
85.     int use_stack_size = (opts && opts->suggested_stack_size >= 0
    
86.                           ? opts->suggested_stack_size
    
87.                           : -1 /* Use system default */);
    
88. 
    
89. #ifdef ETHR_MODIFIED_DEFAULT_STACK_SIZE
    
90.     if (use_stack_size < 0)
    
91.         use_stack_size = ETHR_MODIFIED_DEFAULT_STACK_SIZE;
    
92. #endif
    
93. 
    
94. #if ETHR_XCHK
    
95.     if (ethr_not_completely_inited__) {
    
96.         ETHR_ASSERT(0);
    
97.         return EACCES;
    
98.     }
    
99.     if (!tid || !func) {
    
100.         ETHR_ASSERT(0);
     
101.         return EINVAL;
     
102.     }
     
103. #endif
     
104. 
     
105.     ethr_atomic32_init(&twd.result, (ethr_sint32_t) -1);
     
106.     twd.tse = ethr_get_ts_event();
     
107.     twd.thr_func = func;
     
108.     twd.arg = arg;
     
109. 
     
110.     res = pthread_attr_init(&attr);
     
111.     if (res != 0)
     
112.         return res;
     
113. 
     
114.     /* Error cleanup needed after this point */
     
115. 
     
116.     /* Schedule child thread in system scope (if possible) ... */
     
117.     res = pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
     
118.     if (res != 0 && res != ENOTSUP)
     
119.         goto error;
     
120. 
     
121.     if (use_stack_size >= 0) {
     
122.         size_t suggested_stack_size = (size_t) use_stack_size;
     
123.         size_t stack_size;
     
124. #ifdef ETHR_DEBUG
     
125.         suggested_stack_size /= 2; /* Make sure we got margin */
     
126. #endif
     
127. #ifdef ETHR_STACK_GUARD_SIZE
     
128.         /* The guard is at least on some platforms included in the stack size
     
129.            passed when creating threads */
     
130.         suggested_stack_size += ETHR_B2KW(ETHR_STACK_GUARD_SIZE);
     
131. #endif
     
132.         if (suggested_stack_size < ethr_min_stack_size__)
     
133.             stack_size = ETHR_KW2B(ethr_min_stack_size__);
     
134.         else if (suggested_stack_size > ethr_max_stack_size__)
     
135.             stack_size = ETHR_KW2B(ethr_max_stack_size__);
     
136.         else
     
137.             stack_size = ETHR_PAGE_ALIGN(ETHR_KW2B(suggested_stack_size));
     
138.         (void) pthread_attr_setstacksize(&attr, stack_size);
     
139.     }
     
140. 
     
141. #ifdef ETHR_STACK_GUARD_SIZE
     
142.     (void) pthread_attr_setguardsize(&attr, ETHR_STACK_GUARD_SIZE);
     
143. #endif
     
144. 
     
145.     /* Detached or joinable... */
     
146.     res = pthread_attr_setdetachstate(&attr,
     
147.                                       (opts && opts->detached
     
148.                                        ? PTHREAD_CREATE_DETACHED
     
149.                                        : PTHREAD_CREATE_JOINABLE));
     
150.     if (res != 0)
     
151.         goto error;
     
152. 
     
153.     /* Call prepare func if it exist */
     
154.     if (ethr_thr_prepare_func__)
     
155.         twd.prep_func_res = ethr_thr_prepare_func__();
     
156.     else
     
157.         twd.prep_func_res = NULL;
     
158. 
     
159.     res = pthread_create((pthread_t *) tid, &attr, thr_wrapper, (void*) &twd);
     
160. 
     
161.     if (res == 0) {
     
162.         int spin_count = child_wait_spin_count;
     
163. 
     
164.         /* Wait for child to initialize... */
     
165.         while (1) {
     
166.             ethr_sint32_t result;
     
167.             ethr_event_reset(&twd.tse->event);
     
168. 
     
169.             result = ethr_atomic32_read(&twd.result);
     
170.             if (result == 0)
     
171.                 break;
     
172. 
     
173.             if (result > 0) {
     
174.                 res = (int) result;
     
175.                 goto error;
     
176.             }
     
177. 
     
178.             res = ethr_event_swait(&twd.tse->event, spin_count);
     
179.             if (res != 0 && res != EINTR)
     
180.                 goto error;
     
181.             spin_count = 0;
     
182.         }
     
183.     }
     
184. 
     
185.     /* Cleanup... */
     
186. 
     
187. error:
     
188.     dres = pthread_attr_destroy(&attr);
     
189.     if (res == 0)
     
190.         res = dres;
     
191.     if (ethr_thr_parent_func__)
     
192.         ethr_thr_parent_func__(twd.prep_func_res);
     
193.     return res;
     
194. }

复制代码

可以看出，线程创建过程是一个标准的pthread线程创建框架。

1. static void *erl_drv_thread_wrapper(void *vdtid)
   
2. {
   
3.     int res;
   
4.     struct ErlDrvTid_ *dtid = (struct ErlDrvTid_ *) vdtid;
   
5.     res = ethr_tsd_set(tid_key, vdtid);
   
6.     if (res != 0)
   
7.         fatal_error(res, "erl_drv_thread_wrapper()");
   
8.     return (*dtid->func)(dtid->arg);
   
9. }
   
10. int
    
11. ethr_tsd_set(ethr_tsd_key key, void *value)
    
12. {
    
13. #if ETHR_XCHK
    
14.     if (ethr_not_inited__) {
    
15.         ETHR_ASSERT(0);
    
16.         return EACCES;
    
17.     }
    
18. #endif
    
19.     return pthread_setspecific((pthread_key_t) key, value);
    
20. }

复制代码

外覆函数通过pthread_setspecific为线程设置kv私有数据结构，这个数据结构是线程的erlang线程描述符ErlDrvTid，然后以用户给出的参数调用用户的函数。

进入NIF世界后，就可以借助很多erlang虚拟机的功能来探索erlang世界了，此时既可以通过erlang来实现功能，也可以通过c来实现功能，可以将各式各样的c系统移植如erlang虚拟机，扩充和丰富erlang的功能，同时减少开发的难度，性能也将得到很大的提高。