EL4121 Embedded System / mbed-os

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   cobaLCDJoyMotor_Thread odometry_omni_3roda_v3 odometry_omni_3roda_v1 odometry_omni_3roda_v2 ... more

TESTS/netsocket/udp_packet_pressure_parallel/main.cpp@0:b74591d5ab33, 2017-12-11 (annotated)

Committer:
be_bryan
Date:
Mon Dec 11 17:54:04 2017 +0000
Revision:
0:b74591d5ab33
motor ++

Who changed what in which revision?

UserRevisionLine numberNew contents of line
be_bryan 0:b74591d5ab33 1 /*
be_bryan 0:b74591d5ab33 2 * Copyright (c) 2013-2017, ARM Limited, All Rights Reserved
be_bryan 0:b74591d5ab33 3 * SPDX-License-Identifier: Apache-2.0
be_bryan 0:b74591d5ab33 4 *
be_bryan 0:b74591d5ab33 5 * Licensed under the Apache License, Version 2.0 (the "License"); you may
be_bryan 0:b74591d5ab33 6 * not use this file except in compliance with the License.
be_bryan 0:b74591d5ab33 7 * You may obtain a copy of the License at
be_bryan 0:b74591d5ab33 8 *
be_bryan 0:b74591d5ab33 9 * http://www.apache.org/licenses/LICENSE-2.0
be_bryan 0:b74591d5ab33 10 *
be_bryan 0:b74591d5ab33 11 * Unless required by applicable law or agreed to in writing, software
be_bryan 0:b74591d5ab33 12 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
be_bryan 0:b74591d5ab33 13 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
be_bryan 0:b74591d5ab33 14 * See the License for the specific language governing permissions and
be_bryan 0:b74591d5ab33 15 * limitations under the License.
be_bryan 0:b74591d5ab33 16 */
be_bryan 0:b74591d5ab33 17
be_bryan 0:b74591d5ab33 18 #ifndef MBED_CONF_APP_CONNECT_STATEMENT
be_bryan 0:b74591d5ab33 19 #error [NOT_SUPPORTED] No network configuration found for this target.
be_bryan 0:b74591d5ab33 20 #endif
be_bryan 0:b74591d5ab33 21
be_bryan 0:b74591d5ab33 22 #ifndef MBED_EXTENDED_TESTS
be_bryan 0:b74591d5ab33 23 #error [NOT_SUPPORTED] Parallel pressure tests are not supported by default
be_bryan 0:b74591d5ab33 24 #endif
be_bryan 0:b74591d5ab33 25
be_bryan 0:b74591d5ab33 26 #include "mbed.h"
be_bryan 0:b74591d5ab33 27 #include MBED_CONF_APP_HEADER_FILE
be_bryan 0:b74591d5ab33 28 #include "UDPSocket.h"
be_bryan 0:b74591d5ab33 29 #include "greentea-client/test_env.h"
be_bryan 0:b74591d5ab33 30 #include "unity/unity.h"
be_bryan 0:b74591d5ab33 31 #include "utest.h"
be_bryan 0:b74591d5ab33 32
be_bryan 0:b74591d5ab33 33 using namespace utest::v1;
be_bryan 0:b74591d5ab33 34
be_bryan 0:b74591d5ab33 35
be_bryan 0:b74591d5ab33 36 #ifndef MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MIN
be_bryan 0:b74591d5ab33 37 #define MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MIN 64
be_bryan 0:b74591d5ab33 38 #endif
be_bryan 0:b74591d5ab33 39
be_bryan 0:b74591d5ab33 40 #ifndef MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MAX
be_bryan 0:b74591d5ab33 41 #define MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MAX 0x80000
be_bryan 0:b74591d5ab33 42 #endif
be_bryan 0:b74591d5ab33 43
be_bryan 0:b74591d5ab33 44 #ifndef MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_TIMEOUT
be_bryan 0:b74591d5ab33 45 #define MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_TIMEOUT 100
be_bryan 0:b74591d5ab33 46 #endif
be_bryan 0:b74591d5ab33 47
be_bryan 0:b74591d5ab33 48 #ifndef MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_SEED
be_bryan 0:b74591d5ab33 49 #define MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_SEED 0x6d626564
be_bryan 0:b74591d5ab33 50 #endif
be_bryan 0:b74591d5ab33 51
be_bryan 0:b74591d5ab33 52 #ifndef MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_THREADS
be_bryan 0:b74591d5ab33 53 #define MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_THREADS 3
be_bryan 0:b74591d5ab33 54 #endif
be_bryan 0:b74591d5ab33 55
be_bryan 0:b74591d5ab33 56 #ifndef MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_DEBUG
be_bryan 0:b74591d5ab33 57 #define MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_DEBUG false
be_bryan 0:b74591d5ab33 58 #endif
be_bryan 0:b74591d5ab33 59
be_bryan 0:b74591d5ab33 60 #define STRINGIZE(x) STRINGIZE2(x)
be_bryan 0:b74591d5ab33 61 #define STRINGIZE2(x) #x
be_bryan 0:b74591d5ab33 62
be_bryan 0:b74591d5ab33 63
be_bryan 0:b74591d5ab33 64 // Simple xorshift pseudorandom number generator
be_bryan 0:b74591d5ab33 65 class RandSeq {
be_bryan 0:b74591d5ab33 66 private:
be_bryan 0:b74591d5ab33 67 uint32_t x;
be_bryan 0:b74591d5ab33 68 uint32_t y;
be_bryan 0:b74591d5ab33 69 static const int A = 15;
be_bryan 0:b74591d5ab33 70 static const int B = 18;
be_bryan 0:b74591d5ab33 71 static const int C = 11;
be_bryan 0:b74591d5ab33 72
be_bryan 0:b74591d5ab33 73 public:
be_bryan 0:b74591d5ab33 74 RandSeq(uint32_t seed=MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_SEED)
be_bryan 0:b74591d5ab33 75 : x(seed), y(seed) {}
be_bryan 0:b74591d5ab33 76
be_bryan 0:b74591d5ab33 77 uint32_t next(void) {
be_bryan 0:b74591d5ab33 78 x ^= x << A;
be_bryan 0:b74591d5ab33 79 x ^= x >> B;
be_bryan 0:b74591d5ab33 80 x ^= y ^ (y >> C);
be_bryan 0:b74591d5ab33 81 return x + y;
be_bryan 0:b74591d5ab33 82 }
be_bryan 0:b74591d5ab33 83
be_bryan 0:b74591d5ab33 84 void skip(size_t size) {
be_bryan 0:b74591d5ab33 85 for (size_t i = 0; i < size; i++) {
be_bryan 0:b74591d5ab33 86 next();
be_bryan 0:b74591d5ab33 87 }
be_bryan 0:b74591d5ab33 88 }
be_bryan 0:b74591d5ab33 89
be_bryan 0:b74591d5ab33 90 void buffer(uint8_t *buffer, size_t size) {
be_bryan 0:b74591d5ab33 91 RandSeq lookahead = *this;
be_bryan 0:b74591d5ab33 92
be_bryan 0:b74591d5ab33 93 for (size_t i = 0; i < size; i++) {
be_bryan 0:b74591d5ab33 94 buffer[i] = lookahead.next() & 0xff;
be_bryan 0:b74591d5ab33 95 }
be_bryan 0:b74591d5ab33 96 }
be_bryan 0:b74591d5ab33 97
be_bryan 0:b74591d5ab33 98 int cmp(uint8_t *buffer, size_t size) {
be_bryan 0:b74591d5ab33 99 RandSeq lookahead = *this;
be_bryan 0:b74591d5ab33 100
be_bryan 0:b74591d5ab33 101 for (size_t i = 0; i < size; i++) {
be_bryan 0:b74591d5ab33 102 int diff = buffer[i] - (lookahead.next() & 0xff);
be_bryan 0:b74591d5ab33 103 if (diff != 0) {
be_bryan 0:b74591d5ab33 104 return diff;
be_bryan 0:b74591d5ab33 105 }
be_bryan 0:b74591d5ab33 106 }
be_bryan 0:b74591d5ab33 107 return 0;
be_bryan 0:b74591d5ab33 108 }
be_bryan 0:b74591d5ab33 109 };
be_bryan 0:b74591d5ab33 110
be_bryan 0:b74591d5ab33 111 // Tries to get the biggest buffer possible on the device. Exponentially
be_bryan 0:b74591d5ab33 112 // grows a buffer until heap runs out of space, and uses half to leave
be_bryan 0:b74591d5ab33 113 // space for the rest of the program
be_bryan 0:b74591d5ab33 114 void generate_buffer(uint8_t **buffer, size_t *size, size_t min, size_t max) {
be_bryan 0:b74591d5ab33 115 size_t i = min;
be_bryan 0:b74591d5ab33 116 while (i < max) {
be_bryan 0:b74591d5ab33 117 void *b = malloc(i);
be_bryan 0:b74591d5ab33 118 if (!b) {
be_bryan 0:b74591d5ab33 119 i /= 8;
be_bryan 0:b74591d5ab33 120 if (i < min) {
be_bryan 0:b74591d5ab33 121 i = min;
be_bryan 0:b74591d5ab33 122 }
be_bryan 0:b74591d5ab33 123 break;
be_bryan 0:b74591d5ab33 124 }
be_bryan 0:b74591d5ab33 125 free(b);
be_bryan 0:b74591d5ab33 126 i *= 2;
be_bryan 0:b74591d5ab33 127 }
be_bryan 0:b74591d5ab33 128
be_bryan 0:b74591d5ab33 129 *buffer = (uint8_t *)malloc(i);
be_bryan 0:b74591d5ab33 130 *size = i;
be_bryan 0:b74591d5ab33 131 TEST_ASSERT(buffer);
be_bryan 0:b74591d5ab33 132 }
be_bryan 0:b74591d5ab33 133
be_bryan 0:b74591d5ab33 134
be_bryan 0:b74591d5ab33 135 // Global variables shared between pressure tests
be_bryan 0:b74591d5ab33 136 NetworkInterface* net;
be_bryan 0:b74591d5ab33 137 SocketAddress udp_addr;
be_bryan 0:b74591d5ab33 138 Timer timer;
be_bryan 0:b74591d5ab33 139 Mutex iomutex;
be_bryan 0:b74591d5ab33 140
be_bryan 0:b74591d5ab33 141 // Single instance of a pressure test
be_bryan 0:b74591d5ab33 142 class PressureTest {
be_bryan 0:b74591d5ab33 143 private:
be_bryan 0:b74591d5ab33 144 uint8_t *buffer;
be_bryan 0:b74591d5ab33 145 size_t buffer_size;
be_bryan 0:b74591d5ab33 146
be_bryan 0:b74591d5ab33 147 UDPSocket sock;
be_bryan 0:b74591d5ab33 148 Thread thread;
be_bryan 0:b74591d5ab33 149
be_bryan 0:b74591d5ab33 150 public:
be_bryan 0:b74591d5ab33 151 PressureTest(uint8_t *buffer, size_t buffer_size)
be_bryan 0:b74591d5ab33 152 : buffer(buffer), buffer_size(buffer_size) {
be_bryan 0:b74591d5ab33 153 }
be_bryan 0:b74591d5ab33 154
be_bryan 0:b74591d5ab33 155 void start() {
be_bryan 0:b74591d5ab33 156 osStatus status = thread.start(callback(this, &PressureTest::run));
be_bryan 0:b74591d5ab33 157 TEST_ASSERT_EQUAL(osOK, status);
be_bryan 0:b74591d5ab33 158 }
be_bryan 0:b74591d5ab33 159
be_bryan 0:b74591d5ab33 160 void join() {
be_bryan 0:b74591d5ab33 161 osStatus status = thread.join();
be_bryan 0:b74591d5ab33 162 TEST_ASSERT_EQUAL(osOK, status);
be_bryan 0:b74591d5ab33 163 }
be_bryan 0:b74591d5ab33 164
be_bryan 0:b74591d5ab33 165 void run() {
be_bryan 0:b74591d5ab33 166 // Tests exponentially growing sequences
be_bryan 0:b74591d5ab33 167 for (size_t size = MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MIN;
be_bryan 0:b74591d5ab33 168 size < MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MAX;
be_bryan 0:b74591d5ab33 169 size *= 2) {
be_bryan 0:b74591d5ab33 170 int err = sock.open(net);
be_bryan 0:b74591d5ab33 171 TEST_ASSERT_EQUAL(0, err);
be_bryan 0:b74591d5ab33 172 iomutex.lock();
be_bryan 0:b74591d5ab33 173 printf("UDP: %s:%d streaming %d bytes\r\n",
be_bryan 0:b74591d5ab33 174 udp_addr.get_ip_address(), udp_addr.get_port(), size);
be_bryan 0:b74591d5ab33 175 iomutex.unlock();
be_bryan 0:b74591d5ab33 176
be_bryan 0:b74591d5ab33 177 sock.set_blocking(false);
be_bryan 0:b74591d5ab33 178
be_bryan 0:b74591d5ab33 179 // Loop to send/recv all data
be_bryan 0:b74591d5ab33 180 RandSeq tx_seq;
be_bryan 0:b74591d5ab33 181 RandSeq rx_seq;
be_bryan 0:b74591d5ab33 182 size_t rx_count = 0;
be_bryan 0:b74591d5ab33 183 size_t tx_count = 0;
be_bryan 0:b74591d5ab33 184 int known_time = timer.read_ms();
be_bryan 0:b74591d5ab33 185 size_t window = buffer_size;
be_bryan 0:b74591d5ab33 186
be_bryan 0:b74591d5ab33 187 while (tx_count < size || rx_count < size) {
be_bryan 0:b74591d5ab33 188 // Send out packets
be_bryan 0:b74591d5ab33 189 if (tx_count < size) {
be_bryan 0:b74591d5ab33 190 size_t chunk_size = size - tx_count;
be_bryan 0:b74591d5ab33 191 if (chunk_size > window) {
be_bryan 0:b74591d5ab33 192 chunk_size = window;
be_bryan 0:b74591d5ab33 193 }
be_bryan 0:b74591d5ab33 194
be_bryan 0:b74591d5ab33 195 tx_seq.buffer(buffer, chunk_size);
be_bryan 0:b74591d5ab33 196 int td = sock.sendto(udp_addr, buffer, chunk_size);
be_bryan 0:b74591d5ab33 197
be_bryan 0:b74591d5ab33 198 if (td > 0) {
be_bryan 0:b74591d5ab33 199 if (MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_DEBUG) {
be_bryan 0:b74591d5ab33 200 iomutex.lock();
be_bryan 0:b74591d5ab33 201 printf("UDP: tx -> %d\r\n", td);
be_bryan 0:b74591d5ab33 202 iomutex.unlock();
be_bryan 0:b74591d5ab33 203 }
be_bryan 0:b74591d5ab33 204 tx_seq.skip(td);
be_bryan 0:b74591d5ab33 205 tx_count += td;
be_bryan 0:b74591d5ab33 206 } else if (td != NSAPI_ERROR_WOULD_BLOCK) {
be_bryan 0:b74591d5ab33 207 // We may fail to send because of buffering issues, revert to
be_bryan 0:b74591d5ab33 208 // last good sequence and cut buffer in half
be_bryan 0:b74591d5ab33 209 if (window > MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MIN) {
be_bryan 0:b74591d5ab33 210 window /= 2;
be_bryan 0:b74591d5ab33 211 }
be_bryan 0:b74591d5ab33 212
be_bryan 0:b74591d5ab33 213 if (MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_DEBUG) {
be_bryan 0:b74591d5ab33 214 iomutex.lock();
be_bryan 0:b74591d5ab33 215 printf("UDP: Not sent (%d), window = %d\r\n", td, window);
be_bryan 0:b74591d5ab33 216 iomutex.unlock();
be_bryan 0:b74591d5ab33 217 }
be_bryan 0:b74591d5ab33 218 }
be_bryan 0:b74591d5ab33 219 }
be_bryan 0:b74591d5ab33 220
be_bryan 0:b74591d5ab33 221 // Prioritize recieving over sending packets to avoid flooding
be_bryan 0:b74591d5ab33 222 // the network while handling erronous packets
be_bryan 0:b74591d5ab33 223 while (rx_count < size) {
be_bryan 0:b74591d5ab33 224 int rd = sock.recvfrom(NULL, buffer, buffer_size);
be_bryan 0:b74591d5ab33 225 TEST_ASSERT(rd > 0 || rd == NSAPI_ERROR_WOULD_BLOCK);
be_bryan 0:b74591d5ab33 226
be_bryan 0:b74591d5ab33 227 if (rd > 0) {
be_bryan 0:b74591d5ab33 228 if (MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_DEBUG) {
be_bryan 0:b74591d5ab33 229 iomutex.lock();
be_bryan 0:b74591d5ab33 230 printf("UDP: rx <- %d\r\n", rd);
be_bryan 0:b74591d5ab33 231 iomutex.unlock();
be_bryan 0:b74591d5ab33 232 }
be_bryan 0:b74591d5ab33 233
be_bryan 0:b74591d5ab33 234 if (rx_seq.cmp(buffer, rd) == 0) {
be_bryan 0:b74591d5ab33 235 rx_seq.skip(rd);
be_bryan 0:b74591d5ab33 236 rx_count += rd;
be_bryan 0:b74591d5ab33 237 known_time = timer.read_ms();
be_bryan 0:b74591d5ab33 238 if (window < MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MAX) {
be_bryan 0:b74591d5ab33 239 window += MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MIN;
be_bryan 0:b74591d5ab33 240 }
be_bryan 0:b74591d5ab33 241 }
be_bryan 0:b74591d5ab33 242 } else if (timer.read_ms() - known_time >
be_bryan 0:b74591d5ab33 243 MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_TIMEOUT) {
be_bryan 0:b74591d5ab33 244 // Dropped packet or out of order, revert to last good sequence
be_bryan 0:b74591d5ab33 245 // and cut buffer in half
be_bryan 0:b74591d5ab33 246 tx_seq = rx_seq;
be_bryan 0:b74591d5ab33 247 tx_count = rx_count;
be_bryan 0:b74591d5ab33 248 known_time = timer.read_ms();
be_bryan 0:b74591d5ab33 249 if (window > MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MIN) {
be_bryan 0:b74591d5ab33 250 window /= 2;
be_bryan 0:b74591d5ab33 251 }
be_bryan 0:b74591d5ab33 252
be_bryan 0:b74591d5ab33 253 if (MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_DEBUG) {
be_bryan 0:b74591d5ab33 254 iomutex.lock();
be_bryan 0:b74591d5ab33 255 printf("UDP: Dropped, window = %d\r\n", window);
be_bryan 0:b74591d5ab33 256 iomutex.unlock();
be_bryan 0:b74591d5ab33 257 }
be_bryan 0:b74591d5ab33 258 } else if (rd == NSAPI_ERROR_WOULD_BLOCK) {
be_bryan 0:b74591d5ab33 259 break;
be_bryan 0:b74591d5ab33 260 }
be_bryan 0:b74591d5ab33 261 }
be_bryan 0:b74591d5ab33 262 }
be_bryan 0:b74591d5ab33 263
be_bryan 0:b74591d5ab33 264 err = sock.close();
be_bryan 0:b74591d5ab33 265 TEST_ASSERT_EQUAL(0, err);
be_bryan 0:b74591d5ab33 266 }
be_bryan 0:b74591d5ab33 267 }
be_bryan 0:b74591d5ab33 268 };
be_bryan 0:b74591d5ab33 269
be_bryan 0:b74591d5ab33 270 PressureTest *pressure_tests[MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_THREADS];
be_bryan 0:b74591d5ab33 271
be_bryan 0:b74591d5ab33 272
be_bryan 0:b74591d5ab33 273 void test_udp_packet_pressure_parallel() {
be_bryan 0:b74591d5ab33 274 uint8_t *buffer;
be_bryan 0:b74591d5ab33 275 size_t buffer_size;
be_bryan 0:b74591d5ab33 276 generate_buffer(&buffer, &buffer_size,
be_bryan 0:b74591d5ab33 277 MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MIN,
be_bryan 0:b74591d5ab33 278 MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MAX);
be_bryan 0:b74591d5ab33 279
be_bryan 0:b74591d5ab33 280 size_t buffer_subsize = buffer_size / MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_THREADS;
be_bryan 0:b74591d5ab33 281 printf("MBED: Generated buffer %d\r\n", buffer_size);
be_bryan 0:b74591d5ab33 282 printf("MBED: Split into %d buffers %d\r\n",
be_bryan 0:b74591d5ab33 283 MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_THREADS,
be_bryan 0:b74591d5ab33 284 buffer_subsize);
be_bryan 0:b74591d5ab33 285
be_bryan 0:b74591d5ab33 286 net = MBED_CONF_APP_OBJECT_CONSTRUCTION;
be_bryan 0:b74591d5ab33 287 int err = MBED_CONF_APP_CONNECT_STATEMENT;
be_bryan 0:b74591d5ab33 288 TEST_ASSERT_EQUAL(0, err);
be_bryan 0:b74591d5ab33 289
be_bryan 0:b74591d5ab33 290 printf("MBED: UDPClient IP address is '%s'\n", net->get_ip_address());
be_bryan 0:b74591d5ab33 291
be_bryan 0:b74591d5ab33 292 udp_addr.set_ip_address(MBED_CONF_APP_ECHO_SERVER_ADDR);
be_bryan 0:b74591d5ab33 293 udp_addr.set_port(MBED_CONF_APP_ECHO_SERVER_PORT);
be_bryan 0:b74591d5ab33 294
be_bryan 0:b74591d5ab33 295 timer.start();
be_bryan 0:b74591d5ab33 296
be_bryan 0:b74591d5ab33 297 // Startup pressure tests in parallel
be_bryan 0:b74591d5ab33 298 for (int i = 0; i < MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_THREADS; i++) {
be_bryan 0:b74591d5ab33 299 pressure_tests[i] = new PressureTest(&buffer[i*buffer_subsize], buffer_subsize);
be_bryan 0:b74591d5ab33 300 pressure_tests[i]->start();
be_bryan 0:b74591d5ab33 301 }
be_bryan 0:b74591d5ab33 302
be_bryan 0:b74591d5ab33 303 for (int i = 0; i < MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_THREADS; i++) {
be_bryan 0:b74591d5ab33 304 pressure_tests[i]->join();
be_bryan 0:b74591d5ab33 305 delete pressure_tests[i];
be_bryan 0:b74591d5ab33 306 }
be_bryan 0:b74591d5ab33 307
be_bryan 0:b74591d5ab33 308 timer.stop();
be_bryan 0:b74591d5ab33 309 printf("MBED: Time taken: %fs\r\n", timer.read());
be_bryan 0:b74591d5ab33 310 printf("MBED: Speed: %.3fkb/s\r\n",
be_bryan 0:b74591d5ab33 311 MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_THREADS*
be_bryan 0:b74591d5ab33 312 8*(2*MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MAX -
be_bryan 0:b74591d5ab33 313 MBED_CFG_UDP_CLIENT_PACKET_PRESSURE_MIN) / (1000*timer.read()));
be_bryan 0:b74591d5ab33 314
be_bryan 0:b74591d5ab33 315 net->disconnect();
be_bryan 0:b74591d5ab33 316 }
be_bryan 0:b74591d5ab33 317
be_bryan 0:b74591d5ab33 318
be_bryan 0:b74591d5ab33 319 // Test setup
be_bryan 0:b74591d5ab33 320 utest::v1::status_t test_setup(const size_t number_of_cases) {
be_bryan 0:b74591d5ab33 321 GREENTEA_SETUP(120, "udp_echo");
be_bryan 0:b74591d5ab33 322 return verbose_test_setup_handler(number_of_cases);
be_bryan 0:b74591d5ab33 323 }
be_bryan 0:b74591d5ab33 324
be_bryan 0:b74591d5ab33 325 Case cases[] = {
be_bryan 0:b74591d5ab33 326 Case("UDP packet pressure parallel", test_udp_packet_pressure_parallel),
be_bryan 0:b74591d5ab33 327 };
be_bryan 0:b74591d5ab33 328
be_bryan 0:b74591d5ab33 329 Specification specification(test_setup, cases);
be_bryan 0:b74591d5ab33 330
be_bryan 0:b74591d5ab33 331 int main() {
be_bryan 0:b74591d5ab33 332 return !Harness::run(specification);
be_bryan 0:b74591d5ab33 333 }