Mercurial > hg > audiostuff

comparison spandsp-0.0.6pre17/spandsp-sim/g1050.c @ 4:26cd8f1ef0b1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
import spandsp-0.0.6pre17
author Peter Meerwald <pmeerw@cosy.sbg.ac.at>
date Fri, 25 Jun 2010 15:50:58 +0200
parents
children
comparison
equal deleted inserted replaced
3:c6c5a16ce2f2 4:26cd8f1ef0b1
1 /*
2 * SpanDSP - a series of DSP components for telephony
3 *
4 * g1050.c - IP network modeling, as per G.1050/TIA-921.
5 *
6 * Written by Steve Underwood <steveu@coppice.org>
7 *
8 * Copyright (C) 2007 Steve Underwood
9 *
10 * All rights reserved.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2, as
14 * published by the Free Software Foundation.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 *
25 * $Id: g1050.c,v 1.17 2009/06/02 14:55:36 steveu Exp $
26 */
27
28 #if defined(HAVE_CONFIG_H)
29 #include "config.h"
30 #endif
31
32 #include <stdlib.h>
33 #include <unistd.h>
34 #include <inttypes.h>
35 #include <string.h>
36 #include <time.h>
37 #include <stdio.h>
38 #include <fcntl.h>
39 #if defined(HAVE_TGMATH_H)
40 #include <tgmath.h>
41 #endif
42 #if defined(HAVE_MATH_H)
43 #define GEN_CONST
44 #include <math.h>
45 #endif
46 #include "floating_fudge.h"
47
48 #include "spandsp.h"
49 #include "spandsp/g1050.h"
50
51 #define PACKET_LOSS_TIME -1
52
53 #define FALSE 0
54 #define TRUE (!FALSE)
55
56 g1050_constants_t g1050_constants[1] =
57 {
58 {
59 {
60 { /* Side A LAN */
61 {
62 0.004, /*! Probability of loss rate change low->high */
63 0.1 /*! Probability of loss rate change high->low */
64 },
65 {
66 {
67 0.0, /*! Probability of an impulse */
68 0.0,
69 },
70 {
71 0.5,
72 0.0
73 }
74 },
75 1.0, /*! Impulse height, based on MTU and bit rate */
76 0.0, /*! Impulse decay coefficient */
77 0.001, /*! Probability of packet loss due to occupancy. */
78 0.15 /*! Probability of packet loss due to a multiple access collision. */
79 },
80 { /* Side A access link */
81 {
82 0.0002, /*! Probability of loss rate change low->high */
83 0.2 /*! Probability of loss rate change high->low */
84 },
85 {
86 {
87 0.001, /*! Probability of an impulse */
88 0.0,
89 },
90 {
91 0.3,
92 0.4
93 }
94 },
95 40.0, /*! Impulse height, based on MTU and bit rate */
96 0.75, /*! Impulse decay coefficient */
97 0.0005, /*! Probability of packet loss due to occupancy. */
98 0.0 /*! Probability of packet loss due to a multiple access collision. */
99 },
100 { /* Side B access link */
101 {
102 0.0002, /*! Probability of loss rate change low->high */
103 0.2 /*! Probability of loss rate change high->low */
104 },
105 {
106 {
107 0.001, /*! Probability of an impulse */
108 0.0,
109 },
110 {
111 0.3,
112 0.4
113 }
114 },
115 40.0, /*! Impulse height, based on MTU and bit rate */
116 0.75, /*! Impulse decay coefficient */
117 0.0005, /*! Probability of packet loss due to occupancy. */
118 0.0 /*! Probability of packet loss due to a multiple access collision. */
119 },
120 { /* Side B LAN */
121 {
122 0.004, /*! Probability of loss rate change low->high */
123 0.1 /*! Probability of loss rate change high->low */
124 },
125 {
126 {
127 0.0, /*! Probability of an impulse */
128 0.0,
129 },
130 {
131 0.5,
132 0.0
133 }
134 },
135 1.0, /*! Impulse height, based on MTU and bit rate */
136 0.0, /*! Impulse decay coefficient */
137 0.001, /*! Probability of packet loss due to occupancy. */
138 0.15 /*! Probability of packet loss due to a multiple access collision. */
139 }
140 }
141 }
142 };
143
144 g1050_channel_speeds_t g1050_speed_patterns[168] =
145 {
146 { 4000000, 0, 128000, 768000, 0, 4000000, 0, 128000, 768000, 0, 0.360},
147 { 4000000, 0, 128000, 768000, 0, 20000000, 0, 128000, 768000, 0, 0.720},
148 { 4000000, 0, 128000, 768000, 0, 100000000, 0, 128000, 768000, 0, 0.360},
149 { 20000000, 0, 128000, 768000, 0, 20000000, 0, 128000, 768000, 0, 0.360},
150 { 20000000, 0, 128000, 768000, 0, 100000000, 0, 128000, 768000, 0, 0.360},
151 {100000000, 0, 128000, 768000, 0, 100000000, 0, 128000, 768000, 0, 0.090},
152 { 4000000, 0, 128000, 1536000, 0, 4000000, 0, 384000, 768000, 0, 0.720},
153 { 4000000, 0, 128000, 1536000, 0, 20000000, 0, 384000, 768000, 0, 1.470},
154 { 4000000, 0, 128000, 1536000, 0, 100000000, 0, 384000, 768000, 0, 0.840},
155 { 20000000, 0, 128000, 1536000, 0, 20000000, 0, 384000, 768000, 0, 0.750},
156 { 20000000, 0, 128000, 1536000, 0, 100000000, 0, 384000, 768000, 0, 0.855},
157 {100000000, 0, 128000, 1536000, 0, 100000000, 0, 384000, 768000, 0, 0.240},
158 { 4000000, 0, 128000, 3000000, 0, 4000000, 0, 384000, 768000, 0, 0.120},
159 { 4000000, 0, 128000, 3000000, 0, 20000000, 0, 384000, 768000, 0, 0.420},
160 { 4000000, 0, 128000, 3000000, 0, 100000000, 0, 384000, 768000, 0, 0.840},
161 { 20000000, 0, 128000, 3000000, 0, 20000000, 0, 384000, 768000, 0, 0.300},
162 { 20000000, 0, 128000, 3000000, 0, 100000000, 0, 384000, 768000, 0, 0.930},
163 {100000000, 0, 128000, 3000000, 0, 100000000, 0, 384000, 768000, 0, 0.390},
164 { 4000000, 0, 384000, 768000, 0, 4000000, 0, 128000, 1536000, 0, 0.720},
165 { 4000000, 0, 384000, 768000, 0, 20000000, 0, 128000, 1536000, 0, 1.470},
166 { 4000000, 0, 384000, 768000, 0, 100000000, 0, 128000, 1536000, 0, 0.840},
167 { 20000000, 0, 384000, 768000, 0, 20000000, 0, 128000, 1536000, 0, 0.750},
168 { 20000000, 0, 384000, 768000, 0, 100000000, 0, 128000, 1536000, 0, 0.855},
169 {100000000, 0, 384000, 768000, 0, 100000000, 0, 128000, 1536000, 0, 0.240},
170 { 4000000, 0, 384000, 1536000, 0, 4000000, 0, 384000, 1536000, 0, 1.440},
171 { 4000000, 0, 384000, 1536000, 0, 20000000, 0, 384000, 1536000, 0, 3.000},
172 { 4000000, 0, 384000, 1536000, 0, 100000000, 0, 384000, 1536000, 0, 1.920},
173 { 20000000, 0, 384000, 1536000, 0, 20000000, 0, 384000, 1536000, 0, 1.563},
174 { 20000000, 0, 384000, 1536000, 0, 100000000, 0, 384000, 1536000, 0, 2.000},
175 {100000000, 0, 384000, 1536000, 0, 100000000, 0, 384000, 1536000, 0, 0.640},
176 { 4000000, 0, 384000, 3000000, 0, 4000000, 0, 384000, 1536000, 0, 0.240},
177 { 4000000, 0, 384000, 3000000, 0, 20000000, 0, 384000, 1536000, 0, 0.850},
178 { 4000000, 0, 384000, 3000000, 0, 100000000, 0, 384000, 1536000, 0, 1.720},
179 { 20000000, 0, 384000, 3000000, 0, 20000000, 0, 384000, 1536000, 0, 0.625},
180 { 20000000, 0, 384000, 3000000, 0, 100000000, 0, 384000, 1536000, 0, 2.025},
181 {100000000, 0, 384000, 3000000, 0, 100000000, 0, 384000, 1536000, 0, 1.040},
182 { 4000000, 0, 384000, 768000, 0, 4000000, 0, 128000, 3000000, 0, 0.120},
183 { 4000000, 0, 384000, 768000, 0, 20000000, 0, 128000, 3000000, 0, 0.420},
184 { 4000000, 0, 384000, 768000, 0, 100000000, 0, 128000, 3000000, 0, 0.840},
185 { 20000000, 0, 384000, 768000, 0, 20000000, 0, 128000, 3000000, 0, 0.300},
186 { 20000000, 0, 384000, 768000, 0, 100000000, 0, 128000, 3000000, 0, 0.930},
187 {100000000, 0, 384000, 768000, 0, 100000000, 0, 128000, 3000000, 0, 0.390},
188 { 4000000, 0, 384000, 1536000, 0, 4000000, 0, 384000, 3000000, 0, 0.240},
189 { 4000000, 0, 384000, 1536000, 0, 20000000, 0, 384000, 3000000, 0, 0.850},
190 { 4000000, 0, 384000, 1536000, 0, 100000000, 0, 384000, 3000000, 0, 1.720},
191 { 20000000, 0, 384000, 1536000, 0, 20000000, 0, 384000, 3000000, 0, 0.625},
192 { 20000000, 0, 384000, 1536000, 0, 100000000, 0, 384000, 3000000, 0, 2.025},
193 {100000000, 0, 384000, 1536000, 0, 100000000, 0, 384000, 3000000, 0, 1.040},
194 { 4000000, 0, 384000, 3000000, 0, 4000000, 0, 384000, 3000000, 0, 0.040},
195 { 4000000, 0, 384000, 3000000, 0, 20000000, 0, 384000, 3000000, 0, 0.200},
196 { 4000000, 0, 384000, 3000000, 0, 100000000, 0, 384000, 3000000, 0, 0.520},
197 { 20000000, 0, 384000, 3000000, 0, 20000000, 0, 384000, 3000000, 0, 0.250},
198 { 20000000, 0, 384000, 3000000, 0, 100000000, 0, 384000, 3000000, 0, 1.300},
199 {100000000, 0, 384000, 3000000, 0, 100000000, 0, 384000, 3000000, 0, 1.690},
200 { 4000000, 0, 128000, 1536000, 0, 20000000, 0, 768000, 1536000, 0, 0.090},
201 { 4000000, 0, 128000, 1536000, 0, 100000000, 0, 768000, 1536000, 0, 0.360},
202 { 20000000, 0, 128000, 1536000, 0, 20000000, 0, 768000, 1536000, 0, 0.090},
203 { 20000000, 0, 128000, 1536000, 0, 100000000, 0, 768000, 1536000, 0, 0.405},
204 {100000000, 0, 128000, 1536000, 0, 100000000, 0, 768000, 1536000, 0, 0.180},
205 { 4000000, 0, 128000, 7000000, 0, 20000000, 0, 768000, 768000, 0, 0.270},
206 { 4000000, 0, 128000, 7000000, 0, 100000000, 0, 768000, 768000, 0, 1.080},
207 { 20000000, 0, 128000, 7000000, 0, 20000000, 0, 768000, 768000, 0, 0.270},
208 { 20000000, 0, 128000, 7000000, 0, 100000000, 0, 768000, 768000, 0, 1.215},
209 {100000000, 0, 128000, 7000000, 0, 100000000, 0, 768000, 768000, 0, 0.540},
210 { 4000000, 0, 128000, 13000000, 0, 20000000, 0, 768000, 13000000, 0, 0.030},
211 { 4000000, 0, 128000, 13000000, 0, 100000000, 0, 768000, 13000000, 0, 0.120},
212 { 20000000, 0, 128000, 13000000, 0, 20000000, 0, 768000, 13000000, 0, 0.030},
213 { 20000000, 0, 128000, 13000000, 0, 100000000, 0, 768000, 13000000, 0, 0.135},
214 {100000000, 0, 128000, 13000000, 0, 100000000, 0, 768000, 13000000, 0, 0.060},
215 { 4000000, 0, 384000, 1536000, 0, 20000000, 0, 1536000, 1536000, 0, 0.180},
216 { 4000000, 0, 384000, 1536000, 0, 100000000, 0, 1536000, 1536000, 0, 0.720},
217 { 20000000, 0, 384000, 1536000, 0, 20000000, 0, 1536000, 1536000, 0, 0.188},
218 { 20000000, 0, 384000, 1536000, 0, 100000000, 0, 1536000, 1536000, 0, 0.870},
219 {100000000, 0, 384000, 1536000, 0, 100000000, 0, 1536000, 1536000, 0, 0.480},
220 { 4000000, 0, 384000, 7000000, 0, 20000000, 0, 768000, 1536000, 0, 0.540},
221 { 4000000, 0, 384000, 7000000, 0, 100000000, 0, 768000, 1536000, 0, 2.160},
222 { 20000000, 0, 384000, 7000000, 0, 20000000, 0, 768000, 1536000, 0, 0.563},
223 { 20000000, 0, 384000, 7000000, 0, 100000000, 0, 768000, 1536000, 0, 2.610},
224 {100000000, 0, 384000, 7000000, 0, 100000000, 0, 768000, 1536000, 0, 1.440},
225 { 4000000, 0, 384000, 13000000, 0, 20000000, 0, 1536000, 13000000, 0, 0.060},
226 { 4000000, 0, 384000, 13000000, 0, 100000000, 0, 1536000, 13000000, 0, 0.240},
227 { 20000000, 0, 384000, 13000000, 0, 20000000, 0, 1536000, 13000000, 0, 0.063},
228 { 20000000, 0, 384000, 13000000, 0, 100000000, 0, 1536000, 13000000, 0, 0.290},
229 {100000000, 0, 384000, 13000000, 0, 100000000, 0, 1536000, 13000000, 0, 0.160},
230 { 4000000, 0, 384000, 1536000, 0, 20000000, 0, 1536000, 3000000, 0, 0.030},
231 { 4000000, 0, 384000, 1536000, 0, 100000000, 0, 1536000, 3000000, 0, 0.120},
232 { 20000000, 0, 384000, 1536000, 0, 20000000, 0, 1536000, 3000000, 0, 0.075},
233 { 20000000, 0, 384000, 1536000, 0, 100000000, 0, 1536000, 3000000, 0, 0.495},
234 {100000000, 0, 384000, 1536000, 0, 100000000, 0, 1536000, 3000000, 0, 0.780},
235 { 4000000, 0, 384000, 7000000, 0, 20000000, 0, 768000, 3000000, 0, 0.090},
236 { 4000000, 0, 384000, 7000000, 0, 100000000, 0, 768000, 3000000, 0, 0.360},
237 { 20000000, 0, 384000, 7000000, 0, 20000000, 0, 768000, 3000000, 0, 0.225},
238 { 20000000, 0, 384000, 7000000, 0, 100000000, 0, 768000, 3000000, 0, 1.485},
239 {100000000, 0, 384000, 7000000, 0, 100000000, 0, 768000, 3000000, 0, 2.340},
240 { 4000000, 0, 384000, 13000000, 0, 20000000, 0, 3000000, 13000000, 0, 0.010},
241 { 4000000, 0, 384000, 13000000, 0, 100000000, 0, 3000000, 13000000, 0, 0.040},
242 { 20000000, 0, 384000, 13000000, 0, 20000000, 0, 3000000, 13000000, 0, 0.025},
243 { 20000000, 0, 384000, 13000000, 0, 100000000, 0, 3000000, 13000000, 0, 0.165},
244 {100000000, 0, 384000, 13000000, 0, 100000000, 0, 3000000, 13000000, 0, 0.260},
245 { 4000000, 0, 768000, 1536000, 0, 20000000, 0, 128000, 1536000, 0, 0.090},
246 { 20000000, 0, 768000, 1536000, 0, 20000000, 0, 128000, 1536000, 0, 0.090},
247 { 20000000, 0, 768000, 1536000, 0, 100000000, 0, 128000, 1536000, 0, 0.405},
248 { 4000000, 0, 768000, 1536000, 0, 100000000, 0, 128000, 1536000, 0, 0.360},
249 {100000000, 0, 768000, 1536000, 0, 100000000, 0, 128000, 1536000, 0, 0.180},
250 { 4000000, 0, 1536000, 1536000, 0, 20000000, 0, 384000, 1536000, 0, 0.180},
251 { 20000000, 0, 1536000, 1536000, 0, 20000000, 0, 384000, 1536000, 0, 0.188},
252 { 20000000, 0, 1536000, 1536000, 0, 100000000, 0, 384000, 1536000, 0, 0.870},
253 { 4000000, 0, 1536000, 1536000, 0, 100000000, 0, 384000, 1536000, 0, 0.720},
254 {100000000, 0, 1536000, 1536000, 0, 100000000, 0, 384000, 1536000, 0, 0.480},
255 { 4000000, 0, 1536000, 3000000, 0, 20000000, 0, 384000, 1536000, 0, 0.030},
256 { 20000000, 0, 1536000, 3000000, 0, 20000000, 0, 384000, 1536000, 0, 0.075},
257 { 20000000, 0, 1536000, 3000000, 0, 100000000, 0, 384000, 1536000, 0, 0.495},
258 { 4000000, 0, 1536000, 3000000, 0, 100000000, 0, 384000, 1536000, 0, 0.120},
259 {100000000, 0, 1536000, 3000000, 0, 100000000, 0, 384000, 1536000, 0, 0.780},
260 { 4000000, 0, 768000, 768000, 0, 20000000, 0, 128000, 7000000, 0, 0.270},
261 { 20000000, 0, 768000, 768000, 0, 20000000, 0, 128000, 7000000, 0, 0.270},
262 { 20000000, 0, 768000, 768000, 0, 100000000, 0, 128000, 7000000, 0, 1.215},
263 { 4000000, 0, 768000, 768000, 0, 100000000, 0, 128000, 7000000, 0, 1.080},
264 {100000000, 0, 768000, 768000, 0, 100000000, 0, 128000, 7000000, 0, 0.540},
265 { 4000000, 0, 768000, 1536000, 0, 20000000, 0, 384000, 7000000, 0, 0.540},
266 { 20000000, 0, 768000, 1536000, 0, 20000000, 0, 384000, 7000000, 0, 0.563},
267 { 20000000, 0, 768000, 1536000, 0, 100000000, 0, 384000, 7000000, 0, 2.610},
268 { 4000000, 0, 768000, 1536000, 0, 100000000, 0, 384000, 7000000, 0, 2.160},
269 {100000000, 0, 768000, 1536000, 0, 100000000, 0, 384000, 7000000, 0, 1.440},
270 { 4000000, 0, 768000, 3000000, 0, 20000000, 0, 384000, 7000000, 0, 0.090},
271 { 20000000, 0, 768000, 3000000, 0, 20000000, 0, 384000, 7000000, 0, 0.225},
272 { 20000000, 0, 768000, 3000000, 0, 100000000, 0, 384000, 7000000, 0, 1.485},
273 { 4000000, 0, 768000, 3000000, 0, 100000000, 0, 384000, 7000000, 0, 0.360},
274 {100000000, 0, 768000, 3000000, 0, 100000000, 0, 384000, 7000000, 0, 2.340},
275 { 4000000, 0, 768000, 13000000, 0, 20000000, 0, 128000, 13000000, 0, 0.030},
276 { 20000000, 0, 768000, 13000000, 0, 20000000, 0, 128000, 13000000, 0, 0.030},
277 { 20000000, 0, 768000, 13000000, 0, 100000000, 0, 128000, 13000000, 0, 0.135},
278 { 4000000, 0, 768000, 13000000, 0, 100000000, 0, 128000, 13000000, 0, 0.120},
279 {100000000, 0, 768000, 13000000, 0, 100000000, 0, 128000, 13000000, 0, 0.060},
280 { 4000000, 0, 1536000, 13000000, 0, 20000000, 0, 384000, 13000000, 0, 0.060},
281 { 20000000, 0, 1536000, 13000000, 0, 20000000, 0, 384000, 13000000, 0, 0.063},
282 { 20000000, 0, 1536000, 13000000, 0, 100000000, 0, 384000, 13000000, 0, 0.290},
283 { 4000000, 0, 1536000, 13000000, 0, 100000000, 0, 384000, 13000000, 0, 0.240},
284 {100000000, 0, 1536000, 13000000, 0, 100000000, 0, 384000, 13000000, 0, 0.160},
285 { 4000000, 0, 3000000, 13000000, 0, 20000000, 0, 384000, 13000000, 0, 0.010},
286 { 20000000, 0, 3000000, 13000000, 0, 20000000, 0, 384000, 13000000, 0, 0.025},
287 { 20000000, 0, 3000000, 13000000, 0, 100000000, 0, 384000, 13000000, 0, 0.165},
288 { 4000000, 0, 3000000, 13000000, 0, 100000000, 0, 384000, 13000000, 0, 0.040},
289 {100000000, 0, 3000000, 13000000, 0, 100000000, 0, 384000, 13000000, 0, 0.260},
290 { 20000000, 0, 1536000, 1536000, 0, 20000000, 0, 1536000, 1536000, 0, 0.023},
291 { 20000000, 0, 1536000, 1536000, 0, 100000000, 0, 1536000, 1536000, 0, 0.180},
292 {100000000, 0, 1536000, 1536000, 0, 100000000, 0, 1536000, 1536000, 0, 0.360},
293 { 20000000, 0, 1536000, 7000000, 0, 20000000, 0, 768000, 1536000, 0, 0.068},
294 { 20000000, 0, 1536000, 7000000, 0, 100000000, 0, 768000, 1536000, 0, 0.540},
295 {100000000, 0, 1536000, 7000000, 0, 100000000, 0, 768000, 1536000, 0, 1.080},
296 { 20000000, 0, 1536000, 13000000, 0, 20000000, 0, 1536000, 13000000, 0, 0.015},
297 { 20000000, 0, 1536000, 13000000, 0, 100000000, 0, 1536000, 13000000, 0, 0.120},
298 {100000000, 0, 1536000, 13000000, 0, 100000000, 0, 1536000, 13000000, 0, 0.240},
299 { 20000000, 0, 768000, 1536000, 0, 20000000, 0, 1536000, 7000000, 0, 0.068},
300 { 20000000, 0, 768000, 1536000, 0, 100000000, 0, 1536000, 7000000, 0, 0.540},
301 {100000000, 0, 768000, 1536000, 0, 100000000, 0, 1536000, 7000000, 0, 1.080},
302 { 20000000, 0, 768000, 7000000, 0, 20000000, 0, 768000, 7000000, 0, 0.203},
303 { 20000000, 0, 768000, 7000000, 0, 100000000, 0, 768000, 7000000, 0, 1.620},
304 {100000000, 0, 768000, 7000000, 0, 100000000, 0, 768000, 7000000, 0, 3.240},
305 { 20000000, 0, 768000, 13000000, 0, 20000000, 0, 7000000, 13000000, 0, 0.023},
306 { 20000000, 0, 768000, 13000000, 0, 100000000, 0, 7000000, 13000000, 0, 0.180},
307 {100000000, 0, 768000, 13000000, 0, 100000000, 0, 7000000, 13000000, 0, 0.360},
308 { 20000000, 0, 7000000, 13000000, 0, 20000000, 0, 768000, 13000000, 0, 0.023},
309 { 20000000, 0, 7000000, 13000000, 0, 100000000, 0, 768000, 13000000, 0, 0.180},
310 {100000000, 0, 7000000, 13000000, 0, 100000000, 0, 768000, 13000000, 0, 0.360},
311 { 20000000, 0, 13000000, 13000000, 0, 20000000, 0, 13000000, 13000000, 0, 0.003},
312 { 20000000, 0, 13000000, 13000000, 0, 100000000, 0, 13000000, 13000000, 0, 0.020},
313 {100000000, 0, 13000000, 13000000, 0, 100000000, 0, 13000000, 13000000, 0, 0.040}
314 };
315
316 g1050_model_t g1050_standard_models[9] =
317 {
318 { /* Severity 0 - no impairment */
319 {
320 0, /*! Percentage likelihood of occurance in scenario A */
321 0, /*! Percentage likelihood of occurance in scenario B */
322 0, /*! Percentage likelihood of occurance in scenario C */
323 },
324 {
325 0.0, /*! Percentage occupancy */
326 1508, /*! MTU */
327 0.0 /*! Peak jitter */
328 },
329 {
330 0.0, /*! Percentage occupancy */
331 512, /*! MTU */
332 0.0 /*! Peak jitter */
333 },
334 {
335 0.0, /*! Basic delay of the regional backbone, in seconds */
336 0.0, /*! Basic delay of the intercontinental backbone, in seconds */
337 0.0, /*! Percentage packet loss of the backbone */
338 0.0, /*! Maximum jitter of the backbone, in seconds */
339 0.0, /*! Interval between the backbone route flapping between two paths, in seconds */
340 0.0, /*! The difference in backbone delay between the two routes we flap between, in seconds */
341 0.0, /*! The interval between link failures, in seconds */
342 0.0, /*! The duration of link failures, in seconds */
343 0.0, /*! Probability of packet loss in the backbone, in percent */
344 0.0 /*! Probability of a packet going out of sequence in the backbone. */
345 },
346 {
347 0.0, /*! Percentage occupancy */
348 512, /*! MTU */
349 0.0 /*! Peak jitter */
350 },
351 {
352 0.0, /*! Percentage occupancy */
353 1508, /*! MTU */
354 0.0 /*! Peak jitter */
355 }
356 },
357 { /* Severity A */
358 {
359 50, /*! Percentage likelihood of occurance in scenario A */
360 5, /*! Percentage likelihood of occurance in scenario B */
361 5, /*! Percentage likelihood of occurance in scenario C */
362 },
363 {
364 1.0, /*! Percentage occupancy */
365 1508, /*! MTU */
366 0.0015 /*! Peak jitter */
367 },
368 {
369 0.0, /*! Percentage occupancy */
370 512, /*! MTU */
371 0.0 /*! Peak jitter */
372 },
373 {
374 0.004, /*! Basic delay of the regional backbone, in seconds */
375 0.016, /*! Basic delay of the intercontinental backbone, in seconds */
376 0.0, /*! Percentage packet loss of the backbone */
377 0.005, /*! Maximum jitter of the backbone, in seconds */
378 0.0, /*! Interval between the backbone route flapping between two paths, in seconds */
379 0.0, /*! The difference in backbone delay between the two routes we flap between, in seconds */
380 0.0, /*! The interval between link failures, in seconds */
381 0.0, /*! The duration of link failures, in seconds */
382 0.0, /*! Probability of packet loss in the backbone, in percent */
383 0.0 /*! Probability of a packet going out of sequence in the backbone. */
384 },
385 {
386 0.0, /*! Percentage occupancy */
387 512, /*! MTU */
388 0.0 /*! Peak jitter */
389 },
390 {
391 1.0, /*! Percentage occupancy */
392 1508, /*! MTU */
393 0.0015 /*! Peak jitter */
394 }
395 },
396 { /* Severity B */
397 {
398 30, /*! Percentage likelihood of occurance in scenario A */
399 25, /*! Percentage likelihood of occurance in scenario B */
400 5, /*! Percentage likelihood of occurance in scenario C */
401 },
402 {
403 2.0, /*! Percentage occupancy */
404 1508, /*! MTU */
405 0.0015 /*! Peak jitter */
406 },
407 {
408 1.0, /*! Percentage occupancy */
409 512, /*! MTU */
410 0.0 /*! Peak jitter */
411 },
412 {
413 0.008, /*! Basic delay of the regional backbone, in seconds */
414 0.032, /*! Basic delay of the intercontinental backbone, in seconds */
415 0.01, /*! Percentage packet loss of the backbone */
416 0.01, /*! Maximum jitter of the backbone, in seconds */
417 3600.0, /*! Interval between the backbone route flapping between two paths, in seconds */
418 0.002, /*! The difference in backbone delay between the two routes we flap between, in seconds */
419 3600.0, /*! The interval between link failures, in seconds */
420 0.064, /*! The duration of link failures, in seconds */
421 0.0, /*! Probability of packet loss in the backbone, in percent */
422 0.0 /*! Probability of a packet going out of sequence in the backbone. */
423 },
424 {
425 1.0, /*! Percentage occupancy */
426 512, /*! MTU */
427 0.0 /*! Peak jitter */
428 },
429 {
430 2.0, /*! Percentage occupancy */
431 1508, /*! MTU */
432 0.0015 /*! Peak jitter */
433 }
434 },
435 { /* Severity C */
436 {
437 15, /*! Percentage likelihood of occurance in scenario A */
438 30, /*! Percentage likelihood of occurance in scenario B */
439 10, /*! Percentage likelihood of occurance in scenario C */
440 },
441 {
442 3.0, /*! Percentage occupancy */
443 1508, /*! MTU */
444 0.0015 /*! Peak jitter */
445 },
446 {
447 2.0, /*! Percentage occupancy */
448 1508, /*! MTU */
449 0.0 /*! Peak jitter */
450 },
451 {
452 0.016, /*! Basic delay of the regional backbone, in seconds */
453 0.064, /*! Basic delay of the intercontinental backbone, in seconds */
454 0.02, /*! Percentage packet loss of the backbone */
455 0.016, /*! Maximum jitter of the backbone, in seconds */
456 1800.0, /*! Interval between the backbone route flapping between two paths, in seconds */
457 0.004, /*! The difference in backbone delay between the two routes we flap between, in seconds */
458 1800.0, /*! The interval between link failures, in seconds */
459 0.128, /*! The duration of link failures, in seconds */
460 0.0, /*! Probability of packet loss in the backbone, in percent */
461 0.0 /*! Probability of a packet going out of sequence in the backbone. */
462 },
463 {
464 2.0, /*! Percentage occupancy */
465 1508, /*! MTU */
466 0.0 /*! Peak jitter */
467 },
468 {
469 3.0, /*! Percentage occupancy */
470 1508, /*! MTU */
471 0.0015 /*! Peak jitter */
472 }
473 },
474 { /* Severity D */
475 {
476 5, /*! Percentage likelihood of occurance in scenario A */
477 25, /*! Percentage likelihood of occurance in scenario B */
478 15, /*! Percentage likelihood of occurance in scenario C */
479 },
480 {
481 5.0, /*! Percentage occupancy */
482 1508, /*! MTU */
483 0.0015 /*! Peak jitter */
484 },
485 {
486 4.0, /*! Percentage occupancy */
487 1508, /*! MTU */
488 0.0 /*! Peak jitter */
489 },
490 {
491 0.032, /*! Basic delay of the regional backbone, in seconds */
492 0.128, /*! Basic delay of the intercontinental backbone, in seconds */
493 0.04, /*! Percentage packet loss of the backbone */
494 0.04, /*! Maximum jitter of the backbone, in seconds */
495 900.0, /*! Interval between the backbone route flapping between two paths, in seconds */
496 0.008, /*! The difference in backbone delay between the two routes we flap between, in seconds */
497 900.0, /*! The interval between link failures, in seconds */
498 0.256, /*! The duration of link failures, in seconds */
499 0.0, /*! Probability of packet loss in the backbone, in percent */
500 0.0 /*! Probability of a packet going out of sequence in the backbone. */
501 },
502 {
503 4.0, /*! Percentage occupancy */
504 1508, /*! MTU */
505 0.0 /*! Peak jitter */
506 },
507 {
508 5.0, /*! Percentage occupancy */
509 1508, /*! MTU */
510 0.0015 /*! Peak jitter */
511 }
512 },
513 { /* Severity E */
514 {
515 0, /*! Percentage likelihood of occurance in scenario A */
516 10, /*! Percentage likelihood of occurance in scenario B */
517 20, /*! Percentage likelihood of occurance in scenario C */
518 },
519 {
520 8.0, /*! Percentage occupancy */
521 1508, /*! MTU */
522 0.0015 /*! Peak jitter */
523 },
524 {
525 8.0, /*! Percentage occupancy */
526 1508, /*! MTU */
527 0.0 /*! Peak jitter */
528 },
529 {
530 0.064, /*! Basic delay of the regional backbone, in seconds */
531 0.196, /*! Basic delay of the intercontinental backbone, in seconds */
532 0.1, /*! Percentage packet loss of the backbone */
533 0.07, /*! Maximum jitter of the backbone, in seconds */
534 480.0, /*! Interval between the backbone route flapping between two paths, in seconds */
535 0.016, /*! The difference in backbone delay between the two routes we flap between, in seconds */
536 480.0, /*! The interval between link failures, in seconds */
537 0.4, /*! The duration of link failures, in seconds */
538 0.0, /*! Probability of packet loss in the backbone, in percent */
539 0.0 /*! Probability of a packet going out of sequence in the backbone. */
540 },
541 {
542 8.0, /*! Percentage occupancy */
543 1508, /*! MTU */
544 0.0 /*! Peak jitter */
545 },
546 {
547 8.0, /*! Percentage occupancy */
548 1508, /*! MTU */
549 0.0015 /*! Peak jitter */
550 }
551 },
552 { /* Severity F */
553 {
554 0, /*! Percentage likelihood of occurance in scenario A */
555 0, /*! Percentage likelihood of occurance in scenario B */
556 25, /*! Percentage likelihood of occurance in scenario C */
557 },
558 {
559 12.0, /*! Percentage occupancy */
560 1508, /*! MTU */
561 0.0015 /*! Peak jitter */
562 },
563 {
564 15.0, /*! Percentage occupancy */
565 1508, /*! MTU */
566 0.0 /*! Peak jitter */
567 },
568 {
569 0.128, /*! Basic delay of the regional backbone, in seconds */
570 0.256, /*! Basic delay of the intercontinental backbone, in seconds */
571 0.2, /*! Percentage packet loss of the backbone */
572 0.1, /*! Maximum jitter of the backbone, in seconds */
573 240.0, /*! Interval between the backbone route flapping between two paths, in seconds */
574 0.032, /*! The difference in backbone delay between the two routes we flap between, in seconds */
575 240.0, /*! The interval between link failures, in seconds */
576 0.8, /*! The duration of link failures, in seconds */
577 0.0, /*! Probability of packet loss in the backbone, in percent */
578 0.0 /*! Probability of a packet going out of sequence in the backbone. */
579 },
580 {
581 15.0, /*! Percentage occupancy */
582 1508, /*! MTU */
583 0.0 /*! Peak jitter */
584 },
585 {
586 12.0, /*! Percentage occupancy */
587 1508, /*! MTU */
588 0.0015 /*! Peak jitter */
589 }
590 },
591 { /* Severity G */
592 {
593 0, /*! Percentage likelihood of occurance in scenario A */
594 0, /*! Percentage likelihood of occurance in scenario B */
595 15, /*! Percentage likelihood of occurance in scenario C */
596 },
597 {
598 16.0, /*! Percentage occupancy */
599 1508, /*! MTU */
600 0.0015 /*! Peak jitter */
601 },
602 {
603 30.0, /*! Percentage occupancy */
604 1508, /*! MTU */
605 0.0 /*! Peak jitter */
606 },
607 {
608 0.256, /*! Basic delay of the regional backbone, in seconds */
609 0.512, /*! Basic delay of the intercontinental backbone, in seconds */
610 0.5, /*! Percentage packet loss of the backbone */
611 0.15, /*! Maximum jitter of the backbone, in seconds */
612 120.0, /*! Interval between the backbone route flapping between two paths, in seconds */
613 0.064, /*! The difference in backbone delay between the two routes we flap between, in seconds */
614 120.0, /*! The interval between link failures, in seconds */
615 1.6, /*! The duration of link failures, in seconds */
616 0.0, /*! Probability of packet loss in the backbone, in percent */
617 0.0 /*! Probability of a packet going out of sequence in the backbone. */
618 },
619 {
620 30.0, /*! Percentage occupancy */
621 1508, /*! MTU */
622 0.0 /*! Peak jitter */
623 },
624 {
625 16.0, /*! Percentage occupancy */
626 1508, /*! MTU */
627 0.0015 /*! Peak jitter */
628 }
629 },
630 { /* Severity H */
631 {
632 0, /*! Percentage likelihood of occurance in scenario A */
633 0, /*! Percentage likelihood of occurance in scenario B */
634 5, /*! Percentage likelihood of occurance in scenario C */
635 },
636 {
637 20.0, /*! Percentage occupancy */
638 1508, /*! MTU */
639 0.0015 /*! Peak jitter */
640 },
641 {
642 50.0, /*! Percentage occupancy */
643 1508, /*! MTU */
644 0.0 /*! Peak jitter */
645 },
646 {
647 0.512, /*! Basic delay of the regional backbone, in seconds */
648 0.768, /*! Basic delay of the intercontinental backbone, in seconds */
649 1.0, /*! Percentage packet loss of the backbone */
650 0.5, /*! Maximum jitter of the backbone, in seconds */
651 60.0, /*! Interval between the backbone route flapping between two paths, in seconds */
652 0.128, /*! The difference in backbone delay between the two routes we flap between, in seconds */
653 60.0, /*! The interval between link failures, in seconds */
654 3.0, /*! The duration of link failures, in seconds */
655 1.0, /*! Probability of packet loss in the backbone, in percent */
656 1.0 /*! Probability of a packet going out of sequence in the backbone. */
657 },
658 {
659 50.0, /*! Percentage occupancy */
660 1508, /*! MTU */
661 0.0 /*! Peak jitter */
662 },
663 {
664 20.0, /*! Percentage occupancy */
665 1508, /*! MTU */
666 0.0015 /*! Peak jitter */
667 }
668 }
669 };
670
671 #if defined(HAVE_DRAND48)
672 static __inline__ void q1050_rand_init(void)
673 {
674 srand48(time(NULL));
675 }
676 /*- End of function --------------------------------------------------------*/
677
678 static __inline__ double q1050_rand(void)
679 {
680 return drand48();
681 }
682 /*- End of function --------------------------------------------------------*/
683 #else
684 static __inline__ void q1050_rand_init(void)
685 {
686 srand(time(NULL));
687 }
688 /*- End of function --------------------------------------------------------*/
689
690 static __inline__ double q1050_rand(void)
691 {
692 return (double) rand()/(double) RAND_MAX;
693 }
694 /*- End of function --------------------------------------------------------*/
695 #endif
696
697 static __inline__ double scale_probability(double prob, double scale)
698 {
699 /* Re-calculate probability based on a different time interval */
700 return 1.0 - pow(1.0 - prob, scale);
701 }
702 /*- End of function --------------------------------------------------------*/
703
704 static void g1050_segment_init(g1050_segment_state_t *s,
705 int link_type,
706 g1050_segment_constants_t *constants,
707 g1050_segment_model_t *parms,
708 int bit_rate,
709 int multiple_access,
710 int qos_enabled,
711 int packet_size,
712 int packet_rate)
713 {
714 double x;
715 double packet_interval;
716
717 memset(s, 0, sizeof(*s));
718
719 packet_interval = 1000.0/packet_rate;
720 /* Some calculatons are common to both LAN and access links, and those that are not. */
721 s->link_type = link_type;
722 s->prob_loss_rate_change[0] = scale_probability(constants->prob_loss_rate_change[0]*parms->percentage_occupancy, 1.0/packet_interval);
723
724 s->serial_delay = packet_size*8.0/bit_rate;
725 if (link_type == G1050_LAN_LINK)
726 {
727 s->prob_loss_rate_change[1] = scale_probability(constants->prob_loss_rate_change[1], 1.0/packet_interval);
728 s->prob_impulse[0] = constants->prob_impulse[0][0];
729 s->prob_impulse[1] = constants->prob_impulse[1][0];
730 s->impulse_coeff = constants->impulse_coeff;
731 s->impulse_height = parms->mtu*(8.0/bit_rate)*(1.0 + parms->percentage_occupancy/constants->impulse_height);
732 }
733 else if (link_type == G1050_ACCESS_LINK)
734 {
735 s->prob_loss_rate_change[1] = scale_probability(constants->prob_loss_rate_change[1]/(1.0 + parms->percentage_occupancy), 1.0/packet_interval);
736 s->prob_impulse[0] = scale_probability(constants->prob_impulse[0][0] + (parms->percentage_occupancy/2000.0), 1.0/packet_interval);
737 s->prob_impulse[1] = scale_probability(constants->prob_impulse[1][0] + (constants->prob_impulse[1][1]*parms->percentage_occupancy/100.0), 1.0/packet_interval);
738 s->impulse_coeff = 1.0 - scale_probability(1.0 - constants->impulse_coeff, 1.0/packet_interval);
739 x = (1.0 - constants->impulse_coeff)/(1.0 - s->impulse_coeff);
740 s->impulse_height = x*parms->mtu*(8.0/bit_rate)*(1.0 + parms->percentage_occupancy/constants->impulse_height);
741 }
742
743 /* The following are calculated the same way for LAN and access links */
744 s->prob_packet_loss = constants->prob_packet_loss*parms->percentage_occupancy;
745 s->qos_enabled = qos_enabled;
746 s->multiple_access = multiple_access;
747 s->prob_packet_collision_loss = constants->prob_packet_collision_loss;
748 s->max_jitter = parms->max_jitter;
749
750 /* The following is common state information to all links. */
751 s->high_loss = FALSE;
752 s->congestion_delay = 0.0;
753 s->last_arrival_time = 0.0;
754
755 /* Count of packets lost in this segment. */
756 s->lost_packets = 0;
757 s->lost_packets_2 = 0;
758 }
759 /*- End of function --------------------------------------------------------*/
760
761 static void g1050_core_init(g1050_core_state_t *s, g1050_core_model_t *parms, int packet_rate)
762 {
763 memset(s, 0, sizeof(*s));
764
765 /* Set up route flapping. */
766 /* This is the length of the period of both the delayed duration and the non-delayed. */
767 s->route_flap_interval = parms->route_flap_interval*G1050_TICKS_PER_SEC;
768
769 /* How much additional delay is added or subtracted during route flaps. */
770 s->route_flap_delta = parms->route_flap_delay;
771
772 /* Current tick count. This is initialized so that we are part way into the first
773 CLEAN interval before the first change occurs. This is a random portion of the
774 period. When we reach the first flap, the flapping in both directions becomes
775 periodic. */
776 s->route_flap_counter = s->route_flap_interval - 99 - floor(s->route_flap_interval*q1050_rand());
777 s->link_failure_interval_ticks = parms->link_failure_interval*G1050_TICKS_PER_SEC;
778
779 /* Link failures occur when the count reaches this number of ticks. */
780 /* Duration of a failure. */
781 s->link_failure_duration_ticks = floor((G1050_TICKS_PER_SEC*parms->link_failure_duration));
782 /* How far into the first CLEAN interval we are. This is like the route flap initialzation. */
783 s->link_failure_counter = s->link_failure_interval_ticks - 99 - floor(s->link_failure_interval_ticks*q1050_rand());
784 s->link_recovery_counter = s->link_failure_duration_ticks;
785
786 s->base_delay = parms->base_regional_delay;
787 s->max_jitter = parms->max_jitter;
788 s->prob_packet_loss = parms->prob_packet_loss/100.0;
789 s->prob_oos = parms->prob_oos/100.0;
790 s->last_arrival_time = 0.0;
791 s->delay_delta = 0;
792
793 /* Count of packets lost in this segment. */
794 s->lost_packets = 0;
795 s->lost_packets_2 = 0;
796 }
797 /*- End of function --------------------------------------------------------*/
798
799 static void g1050_segment_model(g1050_segment_state_t *s, double delays[], int len)
800 {
801 int i;
802 int lose;
803 int was_high_loss;
804 double impulse;
805 double slice_delay;
806
807 /* Compute delay and loss value for each time slice. */
808 for (i = 0; i < len; i++)
809 {
810 lose = FALSE;
811 /* Initialize delay to the serial delay plus some jitter. */
812 slice_delay = s->serial_delay + s->max_jitter*q1050_rand();
813 /* If no QoS, do congestion delay and packet loss analysis. */
814 if (!s->qos_enabled)
815 {
816 /* To match the logic in G.1050 we need to record the current loss state, before
817 checking if we should change. */
818 was_high_loss = s->high_loss;
819 /* Toggle between the low-loss and high-loss states, based on the transition probability. */
820 if (q1050_rand() < s->prob_loss_rate_change[was_high_loss])
821 s->high_loss = !s->high_loss;
822 impulse = 0.0;
823 if (q1050_rand() < s->prob_impulse[was_high_loss])
824 {
825 impulse = s->impulse_height;
826 if (!was_high_loss || s->link_type == G1050_LAN_LINK)
827 impulse *= q1050_rand();
828 }
829
830 if (was_high_loss && q1050_rand() < s->prob_packet_loss)
831 lose = TRUE;
832 /* Single pole LPF for the congestion delay impulses. */
833 s->congestion_delay = s->congestion_delay*s->impulse_coeff + impulse*(1.0 - s->impulse_coeff);
834 slice_delay += s->congestion_delay;
835 }
836 /* If duplex mismatch on LAN, packet loss based on loss probability. */
837 if (s->multiple_access && (q1050_rand() < s->prob_packet_collision_loss))
838 lose = TRUE;
839 /* Put computed delay into time slice array. */
840 if (lose)
841 {
842 delays[i] = PACKET_LOSS_TIME;
843 s->lost_packets++;
844 }
845 else
846 {
847 delays[i] = slice_delay;
848 }
849 }
850 }
851 /*- End of function --------------------------------------------------------*/
852
853 static void g1050_core_model(g1050_core_state_t *s, double delays[], int len)
854 {
855 int32_t i;
856 int lose;
857 double jitter_delay;
858
859 for (i = 0; i < len; i++)
860 {
861 lose = FALSE;
862 jitter_delay = s->base_delay + s->max_jitter*q1050_rand();
863 /* Route flapping */
864 if (--s->route_flap_counter <= 0)
865 {
866 /* Route changed */
867 s->delay_delta = s->route_flap_delta - s->delay_delta;
868 s->route_flap_counter = s->route_flap_interval;
869 }
870 if (q1050_rand() < s->prob_packet_loss)
871 lose = TRUE;
872 /* Link failures */
873 if (--s->link_failure_counter <= 0)
874 {
875 /* We are in a link failure */
876 lose = TRUE;
877 if (--s->link_recovery_counter <= 0)
878 {
879 /* Leave failure state. */
880 s->link_failure_counter = s->link_failure_interval_ticks;
881 s->link_recovery_counter = s->link_failure_duration_ticks;
882 lose = FALSE;
883 }
884 }
885 if (lose)
886 {
887 delays[i] = PACKET_LOSS_TIME;
888 s->lost_packets++;
889 }
890 else
891 {
892 delays[i] = jitter_delay + s->delay_delta;
893 }
894 }
895 }
896 /*- End of function --------------------------------------------------------*/
897
898 static int g1050_segment_delay(g1050_segment_state_t *s,
899 double base_time,
900 double arrival_times[],
901 double delays[],
902 int num_packets)
903 {
904 int i;
905 int32_t departure_time;
906 int lost_packets;
907
908 /* Add appropriate delays to the packets for the segments before the core. */
909 lost_packets = 0;
910 for (i = 0; i < num_packets; i++)
911 {
912 /* Apply half a millisecond of rounding, as we working in millisecond steps. */
913 departure_time = (arrival_times[i] + 0.0005 - base_time)*G1050_TICKS_PER_SEC;
914 if (arrival_times[i] == PACKET_LOSS_TIME)
915 {
916 /* Lost already */
917 }
918 else if (delays[departure_time] == PACKET_LOSS_TIME)
919 {
920 arrival_times[i] = PACKET_LOSS_TIME;
921 lost_packets++;
922 }
923 else
924 {
925 arrival_times[i] += delays[departure_time];
926 if (arrival_times[i] < s->last_arrival_time)
927 arrival_times[i] = s->last_arrival_time;
928 else
929 s->last_arrival_time = arrival_times[i];
930 }
931 }
932 return lost_packets;
933 }
934 /*- End of function --------------------------------------------------------*/
935
936 static int g1050_segment_delay_preserve_order(g1050_segment_state_t *s,
937 double base_time,
938 double arrival_times_a[],
939 double arrival_times_b[],
940 double delays[],
941 int num_packets)
942 {
943 int i;
944 int j;
945 int departure_time;
946 double last_arrival_time;
947 double last_arrival_time_temp;
948 int lost_packets;
949
950 /* Add appropriate delays to the packets for the segments after the core. */
951 last_arrival_time = 0.0;
952 last_arrival_time_temp = 0.0;
953 lost_packets = 0;
954 for (i = 0; i < num_packets; i++)
955 {
956 /* We need to preserve the order that came out of the core, so we
957 use an alternate array for the results. */
958 /* Apply half a millisecond of rounding, as we working in millisecond steps. */
959 departure_time = (arrival_times_a[i] + 0.0005 - base_time)*G1050_TICKS_PER_SEC;
960 if (arrival_times_a[i] == PACKET_LOSS_TIME)
961 {
962 /* Lost already */
963 arrival_times_b[i] = PACKET_LOSS_TIME;
964 }
965 else if (delays[departure_time] == PACKET_LOSS_TIME)
966 {
967 arrival_times_b[i] = PACKET_LOSS_TIME;
968 lost_packets++;
969 }
970 else
971 {
972 arrival_times_b[i] = arrival_times_a[i] + delays[departure_time];
973 if (arrival_times_a[i] < last_arrival_time)
974 {
975 /* If a legitimate out of sequence packet is detected, search
976 back a fixed amount of time to preserve order. */
977 for (j = i - 1; j >= 0; j--)
978 {
979 if ((arrival_times_a[j] != PACKET_LOSS_TIME)
980 &&
981 (arrival_times_b[j] != PACKET_LOSS_TIME))
982 {
983 if ((arrival_times_a[i] - arrival_times_a[j]) > SEARCHBACK_PERIOD)
984 break;
985 if ((arrival_times_a[j] > arrival_times_a[i])
986 &&
987 (arrival_times_b[j] < arrival_times_b[i]))
988 {
989 arrival_times_b[j] = arrival_times_b[i];
990 }
991 }
992 }
993 }
994 else
995 {
996 last_arrival_time = arrival_times_a[i];
997 if (arrival_times_b[i] < last_arrival_time_temp)
998 arrival_times_b[i] = last_arrival_time_temp;
999 else
1000 last_arrival_time_temp = arrival_times_b[i];
1001 }
1002 }
1003 }
1004 return lost_packets;
1005 }
1006 /*- End of function --------------------------------------------------------*/
1007
1008 static int g1050_core_delay(g1050_core_state_t *s,
1009 double base_time,
1010 double arrival_times[],
1011 double delays[],
1012 int num_packets)
1013 {
1014 int i;
1015 int departure_time;
1016 int lost_packets;
1017
1018 /* This element does NOT preserve packet order. */
1019 lost_packets = 0;
1020 for (i = 0; i < num_packets; i++)
1021 {
1022 /* Apply half a millisecond of rounding, as we working in millisecond steps. */
1023 departure_time = (arrival_times[i] + 0.0005 - base_time)*G1050_TICKS_PER_SEC;
1024 if (arrival_times[i] == PACKET_LOSS_TIME)
1025 {
1026 /* Lost already */
1027 }
1028 else if (delays[departure_time] == PACKET_LOSS_TIME)
1029 {
1030 arrival_times[i] = PACKET_LOSS_TIME;
1031 lost_packets++;
1032 }
1033 else
1034 {
1035 /* Not lost. Compute arrival time. */
1036 arrival_times[i] += delays[departure_time];
1037 if (arrival_times[i] < s->last_arrival_time)
1038 {
1039 /* This packet is EARLIER than the last one. It is out of order! */
1040 /* Do we allow it to stay out of order? */
1041 if (q1050_rand() >= s->prob_oos)
1042 arrival_times[i] = s->last_arrival_time;
1043 }
1044 else
1045 {
1046 /* Packet is in the correct order, relative to the last one. */
1047 s->last_arrival_time = arrival_times[i];
1048 }
1049 }
1050 }
1051 return lost_packets;
1052 }
1053 /*- End of function --------------------------------------------------------*/
1054
1055 static void g1050_simulate_chunk(g1050_state_t *s)
1056 {
1057 int i;
1058
1059 s->base_time += 1.0;
1060
1061 memcpy(&s->segment[0].delays[0], &s->segment[0].delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->segment[0].delays[0]));
1062 g1050_segment_model(&s->segment[0], &s->segment[0].delays[2*G1050_TICKS_PER_SEC], G1050_TICKS_PER_SEC);
1063
1064 memcpy(&s->segment[1].delays[0], &s->segment[1].delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->segment[1].delays[0]));
1065 g1050_segment_model(&s->segment[1], &s->segment[1].delays[2*G1050_TICKS_PER_SEC], G1050_TICKS_PER_SEC);
1066
1067 memcpy(&s->core.delays[0], &s->core.delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->core.delays[0]));
1068 g1050_core_model(&s->core, &s->core.delays[2*G1050_TICKS_PER_SEC], G1050_TICKS_PER_SEC);
1069
1070 memcpy(&s->segment[2].delays[0], &s->segment[2].delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->segment[2].delays[0]));
1071 g1050_segment_model(&s->segment[2], &s->segment[2].delays[2*G1050_TICKS_PER_SEC], G1050_TICKS_PER_SEC);
1072
1073 memcpy(&s->segment[3].delays[0], &s->segment[3].delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->segment[3].delays[0]));
1074 g1050_segment_model(&s->segment[3], &s->segment[3].delays[2*G1050_TICKS_PER_SEC], G1050_TICKS_PER_SEC);
1075
1076 memcpy(&s->arrival_times_1[0], &s->arrival_times_1[s->packet_rate], 2*s->packet_rate*sizeof(s->arrival_times_1[0]));
1077 memcpy(&s->arrival_times_2[0], &s->arrival_times_2[s->packet_rate], 2*s->packet_rate*sizeof(s->arrival_times_2[0]));
1078 for (i = 0; i < s->packet_rate; i++)
1079 {
1080 s->arrival_times_1[2*s->packet_rate + i] = s->base_time + 2.0 + (double) i/(double) s->packet_rate;
1081 s->arrival_times_2[2*s->packet_rate + i] = 0.0;
1082 }
1083
1084 s->segment[0].lost_packets_2 += g1050_segment_delay(&s->segment[0], s->base_time, s->arrival_times_1, s->segment[0].delays, s->packet_rate);
1085 s->segment[1].lost_packets_2 += g1050_segment_delay(&s->segment[1], s->base_time, s->arrival_times_1, s->segment[1].delays, s->packet_rate);
1086 s->core.lost_packets_2 += g1050_core_delay(&s->core, s->base_time, s->arrival_times_1, s->core.delays, s->packet_rate);
1087 s->segment[2].lost_packets_2 += g1050_segment_delay_preserve_order(&s->segment[2], s->base_time, s->arrival_times_1, s->arrival_times_2, s->segment[2].delays, s->packet_rate);
1088 s->segment[3].lost_packets_2 += g1050_segment_delay_preserve_order(&s->segment[3], s->base_time, s->arrival_times_2, s->arrival_times_1, s->segment[3].delays, s->packet_rate);
1089 }
1090 /*- End of function --------------------------------------------------------*/
1091
1092 SPAN_DECLARE(g1050_state_t *) g1050_init(int model,
1093 int speed_pattern,
1094 int packet_size,
1095 int packet_rate)
1096 {
1097 g1050_state_t *s;
1098 g1050_constants_t *constants;
1099 g1050_channel_speeds_t *sp;
1100 g1050_model_t *mo;
1101 int i;
1102
1103 /* If the random generator has not been seeded it might give endless
1104 zeroes - it depends on the platform. */
1105 for (i = 0; i < 10; i++)
1106 {
1107 if (q1050_rand() != 0.0)
1108 break;
1109 }
1110 if (i >= 10)
1111 q1050_rand_init();
1112 if ((s = (g1050_state_t *) malloc(sizeof(*s))) == NULL)
1113 return NULL;
1114 memset(s, 0, sizeof(*s));
1115
1116 constants = &g1050_constants[0];
1117 sp = &g1050_speed_patterns[speed_pattern - 1];
1118 mo = &g1050_standard_models[model];
1119
1120 memset(s, 0, sizeof(*s));
1121
1122 s->packet_rate = packet_rate;
1123 s->packet_size = packet_size;
1124
1125 g1050_segment_init(&s->segment[0],
1126 G1050_LAN_LINK,
1127 &constants->segment[0],
1128 &mo->sidea_lan,
1129 sp->sidea_lan_bit_rate,
1130 sp->sidea_lan_multiple_access,
1131 FALSE,
1132 packet_size,
1133 packet_rate);
1134 g1050_segment_init(&s->segment[1],
1135 G1050_ACCESS_LINK,
1136 &constants->segment[1],
1137 &mo->sidea_access_link,
1138 sp->sidea_access_link_bit_rate_ab,
1139 FALSE,
1140 sp->sidea_access_link_qos_enabled,
1141 packet_size,
1142 packet_rate);
1143 g1050_core_init(&s->core, &mo->core, packet_rate);
1144 g1050_segment_init(&s->segment[2],
1145 G1050_ACCESS_LINK,
1146 &constants->segment[2],
1147 &mo->sideb_access_link,
1148 sp->sideb_access_link_bit_rate_ba,
1149 FALSE,
1150 sp->sideb_access_link_qos_enabled,
1151 packet_size,
1152 packet_rate);
1153 g1050_segment_init(&s->segment[3],
1154 G1050_LAN_LINK,
1155 &constants->segment[3],
1156 &mo->sideb_lan,
1157 sp->sideb_lan_bit_rate,
1158 sp->sideb_lan_multiple_access,
1159 FALSE,
1160 packet_size,
1161 packet_rate);
1162
1163 s->base_time = 0.0;
1164 /* Start with enough of the future modelled to allow for the worst jitter.
1165 After this we will always keep at least 2 seconds of the future modelled. */
1166 g1050_segment_model(&s->segment[0], s->segment[0].delays, 3*G1050_TICKS_PER_SEC);
1167 g1050_segment_model(&s->segment[1], s->segment[1].delays, 3*G1050_TICKS_PER_SEC);
1168 g1050_core_model(&s->core, s->core.delays, 3*G1050_TICKS_PER_SEC);
1169 g1050_segment_model(&s->segment[2], s->segment[2].delays, 3*G1050_TICKS_PER_SEC);
1170 g1050_segment_model(&s->segment[3], s->segment[3].delays, 3*G1050_TICKS_PER_SEC);
1171
1172 /* Initialise the arrival times to the departure times */
1173 for (i = 0; i < 3*s->packet_rate; i++)
1174 {
1175 s->arrival_times_1[i] = s->base_time + (double) i/(double)s->packet_rate;
1176 s->arrival_times_2[i] = 0.0;
1177 }
1178
1179 s->segment[0].lost_packets_2 += g1050_segment_delay(&s->segment[0], s->base_time, s->arrival_times_1, s->segment[0].delays, s->packet_rate);
1180 s->segment[1].lost_packets_2 += g1050_segment_delay(&s->segment[1], s->base_time, s->arrival_times_1, s->segment[1].delays, s->packet_rate);
1181 s->core.lost_packets_2 += g1050_core_delay(&s->core, s->base_time, s->arrival_times_1, s->core.delays, s->packet_rate);
1182 s->segment[2].lost_packets_2 += g1050_segment_delay_preserve_order(&s->segment[2], s->base_time, s->arrival_times_1, s->arrival_times_2, s->segment[2].delays, s->packet_rate);
1183 s->segment[3].lost_packets_2 += g1050_segment_delay_preserve_order(&s->segment[3], s->base_time, s->arrival_times_2, s->arrival_times_1, s->segment[3].delays, s->packet_rate);
1184
1185 s->first = NULL;
1186 s->last = NULL;
1187 return s;
1188 }
1189 /*- End of function --------------------------------------------------------*/
1190
1191 SPAN_DECLARE(void) g1050_dump_parms(int model, int speed_pattern)
1192 {
1193 g1050_channel_speeds_t *sp;
1194 g1050_model_t *mo;
1195
1196 sp = &g1050_speed_patterns[speed_pattern - 1];
1197 mo = &g1050_standard_models[model];
1198
1199 printf("Model %d%c\n", speed_pattern, 'A' + model - 1);
1200 printf("LOO %.6f%% %.6f%% %.6f%%\n", mo->loo[0]*sp->loo/100.0, mo->loo[1]*sp->loo/100.0, mo->loo[2]*sp->loo/100.0);
1201 printf("Side A LAN %dbps, %.3f%% occupancy, MTU %d, %s MA\n", sp->sidea_lan_bit_rate, mo->sidea_lan.percentage_occupancy, mo->sidea_lan.mtu, (sp->sidea_lan_multiple_access) ? "" : "no");
1202 printf("Side A access %dbps, %.3f%% occupancy, MTU %d, %s QoS\n", sp->sidea_access_link_bit_rate_ab, mo->sidea_access_link.percentage_occupancy, mo->sidea_access_link.mtu, (sp->sidea_access_link_qos_enabled) ? "" : "no");
1203 printf("Core delay %.4fs (%.4fs), peak jitter %.4fs, prob loss %.4f%%, prob OOS %.4f%%\n", mo->core.base_regional_delay, mo->core.base_intercontinental_delay, mo->core.max_jitter, mo->core.prob_packet_loss, mo->core.prob_oos);
1204 printf(" Route flap interval %.4fs, delay change %.4fs\n", mo->core.route_flap_interval, mo->core.route_flap_delay);
1205 printf(" Link failure interval %.4fs, duration %.4fs\n", mo->core.link_failure_interval, mo->core.link_failure_duration);
1206 printf("Side B access %dbps, %.3f%% occupancy, MTU %d, %s QoS\n", sp->sideb_access_link_bit_rate_ba, mo->sideb_access_link.percentage_occupancy, mo->sideb_access_link.mtu, (sp->sideb_access_link_qos_enabled) ? "" : "no");
1207 printf("Side B LAN %dbps, %.3f%% occupancy, MTU %d, %s MA\n", sp->sideb_lan_bit_rate, mo->sideb_lan.percentage_occupancy, mo->sideb_lan.mtu, (sp->sideb_lan_multiple_access) ? "" : "no");
1208 }
1209 /*- End of function --------------------------------------------------------*/
1210
1211 SPAN_DECLARE(int) g1050_put(g1050_state_t *s, const uint8_t buf[], int len, int seq_no, double departure_time)
1212 {
1213 g1050_queue_element_t *element;
1214 g1050_queue_element_t *e;
1215 double arrival_time;
1216
1217 while (departure_time >= s->base_time + 1.0)
1218 g1050_simulate_chunk(s);
1219 arrival_time = s->arrival_times_1[(int) ((departure_time - s->base_time)*(double) s->packet_rate + 0.5)];
1220 if (arrival_time < 0)
1221 {
1222 /* This packet is lost */
1223 return 0;
1224 }
1225 if ((element = (g1050_queue_element_t *) malloc(sizeof(*element) + len)) == NULL)
1226 return -1;
1227 element->next = NULL;
1228 element->prev = NULL;
1229 element->seq_no = seq_no;
1230 element->departure_time = departure_time;
1231 element->arrival_time = arrival_time;
1232 element->len = len;
1233 memcpy(element->pkt, buf, len);
1234 /* Add it to the queue, in order */
1235 if (s->last == NULL)
1236 {
1237 /* The queue is empty */
1238 s->first =
1239 s->last = element;
1240 }
1241 else
1242 {
1243 for (e = s->last; e; e = e->prev)
1244 {
1245 if (e->arrival_time <= arrival_time)
1246 break;
1247 }
1248 if (e)
1249 {
1250 element->next = e->next;
1251 element->prev = e;
1252 e->next = element;
1253 }
1254 else
1255 {
1256 element->next = s->first;
1257 s->first = element;
1258 }
1259 if (element->next)
1260 element->next->prev = element;
1261 else
1262 s->last = element;
1263 }
1264 //printf(">> Seq %d, departs %f, arrives %f\n", seq_no, departure_time, arrival_time);
1265 return len;
1266 }
1267 /*- End of function --------------------------------------------------------*/
1268
1269 SPAN_DECLARE(int) g1050_get(g1050_state_t *s, uint8_t buf[], int max_len, double current_time, int *seq_no, double *departure_time, double *arrival_time)
1270 {
1271 int len;
1272 g1050_queue_element_t *element;
1273
1274 element = s->first;
1275 if (element == NULL)
1276 {
1277 if (seq_no)
1278 *seq_no = -1;
1279 if (departure_time)
1280 *departure_time = -1;
1281 if (arrival_time)
1282 *arrival_time = -1;
1283 return -1;
1284 }
1285 if (element->arrival_time > current_time)
1286 {
1287 if (seq_no)
1288 *seq_no = element->seq_no;
1289 if (departure_time)
1290 *departure_time = element->departure_time;
1291 if (arrival_time)
1292 *arrival_time = element->arrival_time;
1293 return -1;
1294 }
1295 /* Return the first packet in the queue */
1296 len = element->len;
1297 memcpy(buf, element->pkt, len);
1298 if (seq_no)
1299 *seq_no = element->seq_no;
1300 if (departure_time)
1301 *departure_time = element->departure_time;
1302 if (arrival_time)
1303 *arrival_time = element->arrival_time;
1304 //printf("<< Seq %d, arrives %f (%f)\n", element->seq_no, element->arrival_time, current_time);
1305
1306 /* Remove it from the queue */
1307 if (s->first == s->last)
1308 s->last = NULL;
1309 s->first = element->next;
1310 if (element->next)
1311 element->next->prev = NULL;
1312 free(element);
1313 return len;
1314 }
1315 /*- End of function --------------------------------------------------------*/
1316
1317 SPAN_DECLARE(void) g1050_queue_dump(g1050_state_t *s)
1318 {
1319 g1050_queue_element_t *e;
1320
1321 printf("Queue scanned forewards\n");
1322 for (e = s->first; e; e = e->next)
1323 printf("Seq %5d, arrival %10.4f, len %3d\n", e->seq_no, e->arrival_time, e->len);
1324 printf("Queue scanned backwards\n");
1325 for (e = s->last; e; e = e->prev)
1326 printf("Seq %5d, arrival %10.4f, len %3d\n", e->seq_no, e->arrival_time, e->len);
1327 }
1328 /*- End of function --------------------------------------------------------*/
1329 /*- End of file ------------------------------------------------------------*/

Repositories maintained by Peter Meerwald, pmeerw@pmeerw.net.