1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
.. -*- rst -*-
.. highlightlang:: none
``grn_thread_*``
================
Summary
-------
Groonga provides thread related APIs with ``grn_thread_`` prefix.
Normally, you don't need to use these APIs.
You may want to use these APIs when you write a Groonga server.
Example
-------
Here is a real word use case of ``grn_thread_*`` APIs by
:doc:`/reference/executables/groonga`. :doc:`/reference/executables/groonga`
increases its thread pool size when the max number of threads is
increased. :doc:`/reference/executables/groonga` decreases its thread
pool size and stops too many threads when the max number of threads is
decreased.
.. code-block :: c
static grn_mutex q_mutex;
static grn_cond q_cond;
static uint32_t nfthreads;
static uint32_t max_nfthreads;
static uint32_t
groonga_get_thread_limit(void *data)
{
return max_nfthreads;
}
static void
groonga_set_thread_limit(uint32_t new_limit, void *data)
{
uint32_t i;
uint32_t current_nfthreads;
MUTEX_LOCK(q_mutex);
current_nfthreads = nfthreads;
max_nfthreads = new_limit;
MUTEX_UNLOCK(q_mutex);
if (current_nfthreads > new_limit) {
for (i = 0; i < current_nfthreads; i++) {
MUTEX_LOCK(q_mutex);
COND_SIGNAL(q_cond);
MUTEX_UNLOCK(q_mutex);
}
}
}
int
main(int argc, char *argv)
{
/* ... */
grn_thread_set_get_limit_func(groonga_get_thread_limit, NULL);
grn_thread_set_set_limit_func(groonga_set_thread_limit, NULL);
grn_init();
/* ... */
}
Reference
---------
.. c:type:: uint32_t (*grn_thread_get_limit_func)(void *data)
It's the type of function that returns the max number of threads.
.. c:type:: void (*grn_thread_set_limit_func)(uint32_t new_limit, void *data)
It's the type of function that sets the max number of threads.
.. c:function:: uint32_t grn_thread_get_limit(void)
It returns the max number of threads.
If :c:type:`grn_thread_get_limit_func` isn't set by
:c:func:`grn_thread_set_get_limit_func()`, it always returns ``0``.
:return: The max number of threads or ``0``.
.. c:function:: void_t grn_thread_set_limit(uint32_t new_limit)
It sets the max number of threads.
If :c:type:`grn_thread_set_limit_func` isn't set by
:c:func:`grn_thread_set_set_limit_func()`, it does nothing.
:param new_limit: The new max number of threads.
.. c:function:: void grn_thread_set_get_limit_func(grn_thread_get_limit_func func, void *data)
It sets the custom function that returns the max number of threads.
``data`` is passed to ``func`` when ``func`` is called from
:c:func:`grn_thread_get_limit()`.
:param func: The custom function that returns the max number of threads.
:param data: An user data to be passed to ``func`` when ``func``
is called.
.. c:function:: void grn_thread_set_set_limit_func(grn_thread_set_limit_func func, void *data)
It sets the custom function that sets the max number of threads.
``data`` is passed to ``func`` when ``func`` is called from
:c:func:`grn_thread_set_limit()`.
:param func: The custom function that sets the max number of threads.
:param data: An user data to be passed to ``func`` when ``func``
is called.
|
