Mercurial > hg > freeDiameter
annotate tests/testfifo.c @ 1293:17e6e6d72c9b
Added tag 1.2.1-rc2 for changeset 13948c684c35
| author | Sebastien Decugis <sdecugis@freediameter.net> |
|---|---|
| date | Thu, 18 Jun 2015 22:58:01 +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 } |