Mercurial > hg > freeDiameter
annotate tests/testfifo.c @ 1264:abf1e51047a1
Display errors in app_acct at error level
author | Sebastien Decugis <sdecugis@freediameter.net> |
---|---|
date | Mon, 12 May 2014 00:16:19 +0800 |
parents | 1af09cc156d6 |
children |
rev | line source |
---|---|
0 | 1 /********************************************************************************************************* |
2 * Software License Agreement (BSD License) * | |
740
4a9f08d6b6ba
Updated my mail address
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
716
diff
changeset
|
3 * Author: Sebastien Decugis <sdecugis@freediameter.net> * |
0 | 4 * * |
1127
1af09cc156d6
Updated copyright information
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1088
diff
changeset
|
5 * Copyright (c) 2013, WIDE Project and NICT * |
0 | 6 * All rights reserved. * |
7 * * | |
8 * Redistribution and use of this software in source and binary forms, with or without modification, are * | |
9 * permitted provided that the following conditions are met: * | |
10 * * | |
11 * * Redistributions of source code must retain the above * | |
12 * copyright notice, this list of conditions and the * | |
13 * following disclaimer. * | |
14 * * | |
15 * * Redistributions in binary form must reproduce the above * | |
16 * copyright notice, this list of conditions and the * | |
17 * following disclaimer in the documentation and/or other * | |
18 * materials provided with the distribution. * | |
19 * * | |
20 * * Neither the name of the WIDE Project or NICT nor the * | |
21 * names of its contributors may be used to endorse or * | |
22 * promote products derived from this software without * | |
23 * specific prior written permission of WIDE Project and * | |
24 * NICT. * | |
25 * * | |
26 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED * | |
27 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * | |
28 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR * | |
29 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * | |
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * | |
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR * | |
32 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * | |
33 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * | |
34 *********************************************************************************************************/ | |
35 | |
36 #include "tests.h" | |
615
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
37 #include <unistd.h> |
716
4784f2cf325f
Fix missing include for limit (should fix test for OpenSUSE)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
662
diff
changeset
|
38 #include <limits.h> |
0 | 39 |
878
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
40 /* Wrapper for pthread_barrier stuff on Mac OS X */ |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
41 #ifndef HAVE_PTHREAD_BAR |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
42 |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
43 #define PTHREAD_BARRIER_SERIAL_THREAD 1 |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
44 typedef struct { |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
45 int count; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
46 int entered; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
47 int serial; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
48 pthread_mutex_t mutex; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
49 pthread_cond_t cond; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
50 } pthread_barrier_t; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
51 |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
52 int pthread_barrier_init(pthread_barrier_t * barrier, int * barrier_attr, int count) |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
53 { |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
54 memset(barrier, 0, sizeof(pthread_barrier_t)); |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
55 barrier->count = count; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
56 pthread_mutex_init(&barrier->mutex, NULL); |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
57 pthread_cond_init(&barrier->cond, NULL); |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
58 return 0; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
59 } |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
60 |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
61 int pthread_barrier_destroy(pthread_barrier_t * barrier) |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
62 { |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
63 pthread_mutex_destroy(&barrier->mutex); |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
64 pthread_cond_destroy(&barrier->cond); |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
65 return 0; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
66 } |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
67 |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
68 int pthread_barrier_wait(pthread_barrier_t * barrier) |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
69 { |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
70 int ret = 0; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
71 int serial; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
72 pthread_mutex_lock(&barrier->mutex); |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
73 serial = barrier->serial; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
74 |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
75 /* first thread gets the special value */ |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
76 if (barrier->entered++ == 0) |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
77 ret = PTHREAD_BARRIER_SERIAL_THREAD; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
78 |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
79 /* Count was achieved? */ |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
80 if (barrier->entered == barrier->count) { |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
81 /* Ok, increase serial, reset number of threads, and signal everyone */ |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
82 barrier->entered = 0; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
83 barrier->serial++; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
84 pthread_cond_broadcast(&barrier->cond); |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
85 } else { |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
86 do { |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
87 pthread_cond_wait(&barrier->cond, &barrier->mutex); |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
88 } while (barrier->serial == serial); |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
89 /* this protects against spurious wakes */ |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
90 } |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
91 pthread_mutex_unlock(&barrier->mutex); |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
92 return 0; |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
93 } |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
94 |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
95 #endif /* HAVE_PTHREAD_BAR */ |
901526bc034c
Added simple implementation of barriers for Mac OS X
Sebastien Decugis <sdecugis@freediameter.net>
parents:
768
diff
changeset
|
96 |
1
bafb831ba688
Fix names to proper case for freeDiameter
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
0
diff
changeset
|
97 /* Structure for testing threshold function */ |
0 | 98 static struct thrh_test { |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
99 struct fifo * queue; /* pointer to the queue */ |
0 | 100 int h_calls; /* number of calls of h_cb */ |
101 int l_calls; /* number of calls of l_cb */ | |
102 } thrh_td; | |
103 | |
104 /* Callbacks for threasholds test */ | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
105 void thrh_cb_h(struct fifo *queue, void **data) |
0 | 106 { |
107 if (thrh_td.h_calls == thrh_td.l_calls) { | |
108 CHECK( NULL, *data ); | |
109 *data = &thrh_td; | |
110 } else { | |
111 CHECK( *data, &thrh_td ); | |
112 } | |
113 CHECK( queue, thrh_td.queue ); | |
114 | |
115 /* Update the count */ | |
116 thrh_td.h_calls ++; | |
117 } | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
118 void thrh_cb_l(struct fifo *queue, void **data) |
0 | 119 { |
120 CHECK( 1, data ? 1 : 0 ); | |
121 CHECK( *data, &thrh_td ); | |
122 | |
123 /* Check the queue parameter is correct */ | |
124 CHECK( queue, thrh_td.queue ); | |
125 | |
126 /* Update the count */ | |
127 thrh_td.l_calls ++; | |
128 /* Cleanup the data ptr if needed */ | |
129 if (thrh_td.l_calls == thrh_td.h_calls) | |
130 *data = NULL; | |
131 /* done */ | |
132 } | |
133 | |
134 | |
135 /* Structure that is passed to the test function */ | |
136 struct test_data { | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
137 struct fifo * queue; /* pointer to the queue */ |
0 | 138 pthread_barrier_t * bar; /* if not NULL, barrier to synchronize before getting messages */ |
139 struct timespec * ts; /* if not NULL, use a timedget instead of a get */ | |
140 int nbr; /* number of messages to retrieve from the queue */ | |
141 }; | |
142 | |
143 /* The test function, to be threaded */ | |
144 static void * test_fct(void * data) | |
145 { | |
146 int ret = 0, i; | |
147 struct msg * msg = NULL; | |
148 struct test_data * td = (struct test_data *) data; | |
149 | |
150 if (td->bar != NULL) { | |
151 ret = pthread_barrier_wait(td->bar); | |
152 if (ret != PTHREAD_BARRIER_SERIAL_THREAD) { | |
153 CHECK( 0, ret); | |
154 } else { | |
155 CHECK( PTHREAD_BARRIER_SERIAL_THREAD, ret); /* just for the traces */ | |
156 } | |
157 } | |
158 | |
159 for (i=0; i< td->nbr; i++) { | |
160 if (td->ts != NULL) { | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
161 CHECK( 0, fd_fifo_timedget(td->queue, &msg, td->ts) ); |
0 | 162 } else { |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
163 CHECK( 0, fd_fifo_get(td->queue, &msg) ); |
0 | 164 } |
165 } | |
166 | |
167 return NULL; | |
168 } | |
169 | |
767
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
170 /* The test function, to be threaded */ |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
171 static int iter = 0; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
172 static void * test_fct2(void * data) |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
173 { |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
174 int i; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
175 int * item; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
176 struct test_data * td = (struct test_data *) data; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
177 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
178 for (i=0; i< td->nbr; i++) { |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
179 item = malloc(sizeof(int)); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
180 CHECK( 1, item ? 1 : 0 ); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
181 *item = i; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
182 CHECK( 0, fd_fifo_post(td->queue, &item) ); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
183 iter++; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
184 } |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
185 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
186 return NULL; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
187 } |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
188 |
0 | 189 |
190 /* Main test routine */ | |
191 int main(int argc, char *argv[]) | |
192 { | |
193 struct timespec ts; | |
194 | |
195 struct msg * msg1 = NULL; | |
196 struct msg * msg2 = NULL; | |
197 struct msg * msg3 = NULL; | |
198 | |
199 /* First, initialize the daemon modules */ | |
200 INIT_FD(); | |
201 | |
202 /* Prolog: create the messages */ | |
203 { | |
204 struct dict_object * acr_model = NULL; | |
205 struct dict_object * cer_model = NULL; | |
206 struct dict_object * dwr_model = NULL; | |
207 | |
10
c5c99c73c2bf
Added some extensions and functions in the daemon
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
8
diff
changeset
|
208 CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_NAME, "Accounting-Request", &acr_model, ENOENT ) ); |
c5c99c73c2bf
Added some extensions and functions in the daemon
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
8
diff
changeset
|
209 CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_NAME, "Capabilities-Exchange-Request", &cer_model, ENOENT ) ); |
c5c99c73c2bf
Added some extensions and functions in the daemon
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
8
diff
changeset
|
210 CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_NAME, "Device-Watchdog-Request", &dwr_model, ENOENT ) ); |
0 | 211 CHECK( 0, fd_msg_new ( acr_model, 0, &msg1 ) ); |
212 CHECK( 0, fd_msg_new ( cer_model, 0, &msg2 ) ); | |
213 CHECK( 0, fd_msg_new ( dwr_model, 0, &msg3 ) ); | |
214 } | |
215 | |
216 /* Basic operation */ | |
217 { | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
218 struct fifo * queue = NULL; |
0 | 219 struct msg * msg = NULL; |
1071
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
220 int max; |
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
221 long long count; |
0 | 222 |
223 /* Create the queue */ | |
767
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
224 CHECK( 0, fd_fifo_new(&queue, 0) ); |
0 | 225 |
226 /* Check the count is 0 */ | |
1071
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
227 CHECK( 0, fd_fifo_length(queue) ); |
0 | 228 |
229 /* Now enqueue */ | |
230 msg = msg1; | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
231 CHECK( 0, fd_fifo_post(queue, &msg) ); |
0 | 232 msg = msg2; |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
233 CHECK( 0, fd_fifo_post(queue, &msg) ); |
0 | 234 msg = msg3; |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
235 CHECK( 0, fd_fifo_post(queue, &msg) ); |
0 | 236 |
237 /* Check the count is 3 */ | |
1071
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
238 CHECK( 3, fd_fifo_length(queue) ); |
0 | 239 |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
240 /* Retrieve the first message using fd_fifo_get */ |
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
241 CHECK( 0, fd_fifo_get(queue, &msg) ); |
0 | 242 CHECK( msg1, msg); |
1071
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
243 CHECK( 2, fd_fifo_length(queue) ); |
0 | 244 |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
245 /* Retrieve the second message using fd_fifo_timedget */ |
0 | 246 CHECK(0, clock_gettime(CLOCK_REALTIME, &ts)); |
247 ts.tv_sec += 1; /* Set the timeout to 1 second */ | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
248 CHECK( 0, fd_fifo_timedget(queue, &msg, &ts) ); |
0 | 249 CHECK( msg2, msg); |
1071
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
250 CHECK( 1, fd_fifo_length(queue) ); |
0 | 251 |
252 /* Retrieve the third message using meq_tryget */ | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
253 CHECK( 0, fd_fifo_tryget(queue, &msg) ); |
0 | 254 CHECK( msg3, msg); |
1071
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
255 CHECK( 0, fd_fifo_length(queue) ); |
0 | 256 |
257 /* Check that another meq_tryget does not block */ | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
258 CHECK( EWOULDBLOCK, fd_fifo_tryget(queue, &msg) ); |
1071
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
259 CHECK( 0, fd_fifo_length(queue) ); |
0 | 260 |
751
c7d9c5477d2f
Add a test for timeout on fifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
740
diff
changeset
|
261 /* Check the timedget actually timesout */ |
c7d9c5477d2f
Add a test for timeout on fifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
740
diff
changeset
|
262 CHECK(0, clock_gettime(CLOCK_REALTIME, &ts)); |
c7d9c5477d2f
Add a test for timeout on fifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
740
diff
changeset
|
263 ts.tv_nsec += 1000000; /* 1 millisecond */ |
c7d9c5477d2f
Add a test for timeout on fifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
740
diff
changeset
|
264 if (ts.tv_nsec >= 1000000000L) { |
c7d9c5477d2f
Add a test for timeout on fifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
740
diff
changeset
|
265 ts.tv_nsec -= 1000000000L; |
c7d9c5477d2f
Add a test for timeout on fifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
740
diff
changeset
|
266 ts.tv_sec += 1; |
c7d9c5477d2f
Add a test for timeout on fifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
740
diff
changeset
|
267 } |
c7d9c5477d2f
Add a test for timeout on fifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
740
diff
changeset
|
268 CHECK( ETIMEDOUT, fd_fifo_timedget(queue, &msg, &ts) ); |
1071
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
269 CHECK( 0, fd_fifo_length(queue) ); |
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
270 |
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
271 /* Post & get another message */ |
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
272 msg = msg1; |
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
273 CHECK( 0, fd_fifo_post(queue, &msg) ); |
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
274 CHECK( 0, fd_fifo_timedget(queue, &msg, &ts) ); |
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
275 CHECK( msg1, msg); |
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
276 |
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
277 /* Check some statistics */ |
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
278 CHECK( 0, fd_fifo_getstats(queue, NULL, NULL, &max, &count, NULL, NULL, NULL) ); |
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
279 CHECK( 3, max ); |
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
280 CHECK( 4, count ); |
751
c7d9c5477d2f
Add a test for timeout on fifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
740
diff
changeset
|
281 |
0 | 282 /* We're done for basic tests */ |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
283 CHECK( 0, fd_fifo_del(&queue) ); |
0 | 284 } |
285 | |
286 /* Test robustness, ensure no messages are lost */ | |
287 { | |
288 #define NBR_MSG 200 | |
289 #define NBR_THREADS 60 | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
290 struct fifo *queue = NULL; |
0 | 291 pthread_barrier_t bar; |
292 struct test_data td_1; | |
293 struct test_data td_2; | |
294 struct msg *msgs[NBR_MSG * NBR_THREADS * 2], *msg; | |
295 pthread_t thr [NBR_THREADS * 2]; | |
296 struct dict_object *dwr_model = NULL; | |
297 int i; | |
615
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
298 int nbr_threads; |
619
45a63d6448ea
Fix wrong operator in testfifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
615
diff
changeset
|
299 #ifdef _POSIX_THREAD_THREADS_MAX |
45a63d6448ea
Fix wrong operator in testfifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
615
diff
changeset
|
300 nbr_threads = _POSIX_THREAD_THREADS_MAX; |
45a63d6448ea
Fix wrong operator in testfifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
615
diff
changeset
|
301 #else /* _POSIX_THREAD_THREADS_MAX */ |
615
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
302 nbr_threads = sysconf(_SC_THREAD_THREADS_MAX); |
619
45a63d6448ea
Fix wrong operator in testfifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
615
diff
changeset
|
303 #endif /* _POSIX_THREAD_THREADS_MAX */ |
45a63d6448ea
Fix wrong operator in testfifo
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
615
diff
changeset
|
304 if ((nbr_threads <= 0) || (nbr_threads > NBR_THREADS * 2)) { |
615
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
305 nbr_threads = NBR_THREADS; |
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
306 } else { |
716
4784f2cf325f
Fix missing include for limit (should fix test for OpenSUSE)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
662
diff
changeset
|
307 TRACE_DEBUG(INFO, "Local limit on number of threads: %d", nbr_threads); |
972 | 308 /* The local limit is below NBR_THREADS */ |
615
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
309 nbr_threads = (nbr_threads / 2) - 1; |
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
310 /* Ensure we create at least a few threads! */ |
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
311 CHECK( 1, nbr_threads >= 10 ? 1 : 0 ); |
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
312 } |
0 | 313 |
314 /* Create the queue */ | |
767
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
315 CHECK( 0, fd_fifo_new(&queue, 0) ); |
0 | 316 |
317 /* Create the barrier */ | |
615
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
318 CHECK( 0, pthread_barrier_init(&bar, NULL, nbr_threads * 2 + 1) ); |
0 | 319 |
320 /* Initialize the ts */ | |
321 CHECK(0, clock_gettime(CLOCK_REALTIME, &ts)); | |
494
6e9c1ea44262
Increase timer for the test
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
10
diff
changeset
|
322 ts.tv_sec += 20; /* Set the timeout to 20 second */ |
0 | 323 |
324 /* Create the messages */ | |
10
c5c99c73c2bf
Added some extensions and functions in the daemon
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
8
diff
changeset
|
325 CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_NAME, "Device-Watchdog-Request", &dwr_model, ENOENT ) ); |
615
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
326 for (i = 0; i < NBR_MSG * nbr_threads * 2; i++) { |
0 | 327 CHECK( 0, fd_msg_new ( dwr_model, 0, &msgs[i] ) ); |
328 } | |
329 | |
330 /* Initialize the test data structures */ | |
331 td_1.queue = queue; | |
332 td_1.bar = &bar; | |
333 td_1.ts = &ts; | |
334 td_1.nbr = NBR_MSG; | |
335 td_2.queue = queue; | |
336 td_2.bar = &bar; | |
337 td_2.ts = NULL; | |
338 td_2.nbr = NBR_MSG; | |
339 | |
340 /* Create the threads */ | |
615
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
341 for (i=0; i < nbr_threads * 2; i++) { |
0 | 342 CHECK( 0, pthread_create( &thr[i], NULL, test_fct, (i & 1) ? &td_1 : &td_2 ) ); |
343 } | |
344 | |
345 /* Synchronize everyone */ | |
346 { | |
347 int ret = pthread_barrier_wait(&bar); | |
348 if (ret != PTHREAD_BARRIER_SERIAL_THREAD) { | |
349 CHECK( 0, ret); | |
350 } else { | |
351 CHECK( PTHREAD_BARRIER_SERIAL_THREAD, ret); /* for trace only */ | |
352 } | |
353 } | |
354 | |
355 /* Now post all the messages */ | |
615
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
356 for (i=0; i < NBR_MSG * nbr_threads * 2; i++) { |
0 | 357 msg = msgs[i]; |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
358 CHECK( 0, fd_fifo_post(queue, &msg) ); |
0 | 359 } |
360 | |
361 /* Join all threads. This blocks if messages are lost... */ | |
615
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
362 for (i=0; i < nbr_threads * 2; i++) { |
0 | 363 CHECK( 0, pthread_join( thr[i], NULL ) ); |
364 } | |
365 | |
366 /* Check the count of the queue is back to 0 */ | |
1071
6ca6cadf209c
Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.
Sebastien Decugis <sdecugis@freediameter.net>
parents:
1060
diff
changeset
|
367 CHECK( 0, fd_fifo_length(queue) ); |
0 | 368 |
369 /* Destroy this queue and the messages */ | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
370 CHECK( 0, fd_fifo_del(&queue) ); |
615
8abafd66a617
Adapt test for systems that cannot create many threads per process, such as OpenSUSE (bouuuuh)
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
494
diff
changeset
|
371 for (i=0; i < NBR_MSG * nbr_threads * 2; i++) { |
0 | 372 CHECK( 0, fd_msg_free( msgs[i] ) ); |
373 } | |
374 } | |
375 | |
376 /* Test thread cancelation */ | |
377 { | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
378 struct fifo *queue = NULL; |
0 | 379 pthread_barrier_t bar; |
380 struct test_data td; | |
381 pthread_t th; | |
382 | |
383 /* Create the queue */ | |
767
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
384 CHECK( 0, fd_fifo_new(&queue, 0) ); |
0 | 385 |
386 /* Create the barrier */ | |
387 CHECK( 0, pthread_barrier_init(&bar, NULL, 2) ); | |
388 | |
389 /* Initialize the ts */ | |
390 CHECK(0, clock_gettime(CLOCK_REALTIME, &ts)); | |
494
6e9c1ea44262
Increase timer for the test
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
10
diff
changeset
|
391 ts.tv_sec += 10; /* Set the timeout to 10 second */ |
0 | 392 |
393 /* Initialize the test data structures */ | |
394 td.queue = queue; | |
395 td.bar = &bar; | |
396 td.ts = &ts; | |
397 td.nbr = 1; | |
398 | |
399 /* Create the thread */ | |
400 CHECK( 0, pthread_create( &th, NULL, test_fct, &td ) ); | |
401 | |
402 /* Wait for the thread to be running */ | |
403 { | |
404 int ret = pthread_barrier_wait(&bar); | |
405 if (ret != PTHREAD_BARRIER_SERIAL_THREAD) { | |
406 CHECK( 0, ret); | |
407 } else { | |
408 CHECK( PTHREAD_BARRIER_SERIAL_THREAD, ret ); | |
409 } | |
410 } | |
411 | |
412 /* Now cancel the thread */ | |
413 CHECK( 0, pthread_cancel( th ) ); | |
414 | |
415 /* Join it */ | |
416 CHECK( 0, pthread_join( th, NULL ) ); | |
417 | |
418 /* Do the same with the other function */ | |
419 td.ts = NULL; | |
420 | |
421 /* Create the thread */ | |
422 CHECK( 0, pthread_create( &th, NULL, test_fct, &td ) ); | |
423 | |
424 /* Wait for the thread to be running */ | |
425 { | |
426 int ret = pthread_barrier_wait(&bar); | |
427 if (ret != PTHREAD_BARRIER_SERIAL_THREAD) { | |
428 CHECK( 0, ret); | |
429 } else { | |
430 CHECK( PTHREAD_BARRIER_SERIAL_THREAD, ret ); | |
431 } | |
432 } | |
433 | |
434 /* Now cancel the thread */ | |
435 CHECK( 0, pthread_cancel( th ) ); | |
436 | |
437 /* Join it */ | |
438 CHECK( 0, pthread_join( th, NULL ) ); | |
439 | |
440 /* Destroy the queue */ | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
441 CHECK( 0, fd_fifo_del(&queue) ); |
0 | 442 } |
443 | |
444 /* Test the threashold function */ | |
445 { | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
446 struct fifo * queue = NULL; |
0 | 447 int i; |
448 struct msg * msg = NULL; | |
449 | |
450 /* Create the queue */ | |
767
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
451 CHECK( 0, fd_fifo_new(&queue, 0) ); |
0 | 452 |
453 /* Prepare the test data */ | |
454 memset(&thrh_td, 0, sizeof(thrh_td)); | |
455 thrh_td.queue = queue; | |
456 | |
457 /* Set the thresholds for the queue */ | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
458 CHECK( 0, fd_fifo_setthrhd ( queue, NULL, 6, thrh_cb_h, 4, thrh_cb_l ) ); |
0 | 459 |
460 /* Post 5 messages, no cb must be called. */ | |
461 for (i=0; i<5; i++) { | |
462 msg = msg1; | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
463 CHECK( 0, fd_fifo_post(queue, &msg) ); |
0 | 464 } /* 5 msg in queue */ |
465 CHECK( 0, thrh_td.h_calls ); | |
466 CHECK( 0, thrh_td.l_calls ); | |
467 | |
468 /* Get all these messages, and check again */ | |
469 for (i=0; i<5; i++) { | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
470 CHECK( 0, fd_fifo_get(queue, &msg) ); |
0 | 471 } /* 0 msg in queue */ |
472 CHECK( 0, thrh_td.h_calls ); | |
473 CHECK( 0, thrh_td.l_calls ); | |
474 | |
475 /* Now, post 6 messages, the high threashold */ | |
476 for (i=0; i<6; i++) { | |
477 msg = msg1; | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
478 CHECK( 0, fd_fifo_post(queue, &msg) ); |
0 | 479 } /* 6 msg in queue */ |
480 CHECK( 1, thrh_td.h_calls ); | |
481 CHECK( 0, thrh_td.l_calls ); | |
482 | |
483 /* Remove 2 messages, to reach the low threshold */ | |
484 for (i=0; i<2; i++) { | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
485 CHECK( 0, fd_fifo_get(queue, &msg) ); |
0 | 486 } /* 4 msg in queue */ |
487 CHECK( 1, thrh_td.h_calls ); | |
488 CHECK( 1, thrh_td.l_calls ); | |
489 | |
490 /* Come again at the high threshold */ | |
491 for (i=0; i<2; i++) { | |
492 msg = msg1; | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
493 CHECK( 0, fd_fifo_post(queue, &msg) ); |
0 | 494 } /* 6 msg in queue */ |
495 CHECK( 2, thrh_td.h_calls ); | |
496 CHECK( 1, thrh_td.l_calls ); | |
497 | |
498 /* Suppose the queue continues to grow */ | |
499 for (i=0; i<6; i++) { | |
500 msg = msg1; | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
501 CHECK( 0, fd_fifo_post(queue, &msg) ); |
0 | 502 } /* 12 msg in queue */ |
503 CHECK( 3, thrh_td.h_calls ); | |
504 CHECK( 1, thrh_td.l_calls ); | |
505 for (i=0; i<5; i++) { | |
506 msg = msg1; | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
507 CHECK( 0, fd_fifo_post(queue, &msg) ); |
0 | 508 } /* 17 msg in queue */ |
509 CHECK( 3, thrh_td.h_calls ); | |
510 CHECK( 1, thrh_td.l_calls ); | |
511 | |
512 /* Now the queue goes back to 0 messages */ | |
513 for (i=0; i<17; i++) { | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
514 CHECK( 0, fd_fifo_get(queue, &msg) ); |
0 | 515 } /* 0 msg in queue */ |
516 CHECK( 3, thrh_td.h_calls ); | |
517 CHECK( 3, thrh_td.l_calls ); | |
518 | |
519 /* We're done for this test */ | |
8
3e143f047f78
Backup for the week-end
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
1
diff
changeset
|
520 CHECK( 0, fd_fifo_del(&queue) ); |
0 | 521 } |
522 | |
767
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
523 /* Test max queue limit */ |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
524 { |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
525 struct fifo *queue = NULL; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
526 struct test_data td; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
527 pthread_t th; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
528 int * item, i; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
529 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
530 /* Create the queue */ |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
531 CHECK( 0, fd_fifo_new(&queue, 10) ); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
532 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
533 /* Initialize the test data structures */ |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
534 td.queue = queue; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
535 td.nbr = 15; |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
536 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
537 CHECK( 0, pthread_create( &th, NULL, test_fct2, &td ) ); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
538 |
768
a5a82d50c25e
Increased delay so that the test has more chances to pass. Wow, Fedora IS slow to create threads...
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
767
diff
changeset
|
539 usleep(100000); /* 100 millisec */ |
767
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
540 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
541 CHECK( 10, iter ); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
542 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
543 CHECK( 0, fd_fifo_tryget(queue, &item) ); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
544 CHECK( 0, *item); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
545 free(item); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
546 |
768
a5a82d50c25e
Increased delay so that the test has more chances to pass. Wow, Fedora IS slow to create threads...
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
767
diff
changeset
|
547 usleep(100000); /* 100 millisec */ |
767
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
548 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
549 CHECK( 11, iter ); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
550 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
551 for (i=1; i<4; i++) { |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
552 CHECK( 0, fd_fifo_get(queue, &item) ); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
553 CHECK( i, *item); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
554 free(item); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
555 } |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
556 |
768
a5a82d50c25e
Increased delay so that the test has more chances to pass. Wow, Fedora IS slow to create threads...
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
767
diff
changeset
|
557 usleep(100000); /* 100 millisec */ |
767
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
558 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
559 CHECK( 14, iter ); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
560 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
561 for (; i < td.nbr; i++) { |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
562 CHECK( 0, fd_fifo_tryget(queue, &item) ); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
563 CHECK( i, *item); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
564 free(item); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
565 } |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
566 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
567 CHECK( 0, pthread_join( th, NULL ) ); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
568 CHECK( 15, iter ); |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
569 |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
570 } |
c47c16436f71
Added a limit on fifo queues to avoid memory exaustion when messages are received faster than handled
Sebastien Decugis <sdecugis@nict.go.jp>
parents:
751
diff
changeset
|
571 |
0 | 572 /* Delete the messages */ |
573 CHECK( 0, fd_msg_free( msg1 ) ); | |
574 CHECK( 0, fd_msg_free( msg2 ) ); | |
575 CHECK( 0, fd_msg_free( msg3 ) ); | |
576 | |
577 /* That's all for the tests yet */ | |
578 PASSTEST(); | |
579 } |