unified MX27, MX25, MX37 trees
[karo-tx-redboot.git] / packages / net / lwip_tcpip / v2_0 / tests / nc_test_slave.c
1 //==========================================================================
2 //
3 //      tests/nc_test_slave.c
4 //
5 //      Network characterizations test (slave portion)
6 //
7 //==========================================================================
8 //####BSDCOPYRIGHTBEGIN####
9 //
10 // -------------------------------------------
11 //
12 // Portions of this software may have been derived from OpenBSD or other sources,
13 // and are covered by the appropriate copyright disclaimers included herein.
14 //
15 // -------------------------------------------
16 //
17 //####BSDCOPYRIGHTEND####
18 //==========================================================================
19 //#####DESCRIPTIONBEGIN####
20 //
21 // Author(s):    gthomas
22 // Contributors: gthomas
23 // Date:         2000-01-10
24 // Purpose:      
25 // Description:  
26 //              
27 //
28 //####DESCRIPTIONEND####
29 //
30 //==========================================================================
31
32 // Network characterization test code - slave portion
33 #include <cyg/kernel/kapi.h>
34 #include <cyg/hal/hal_arch.h>
35
36 #include "nc_test_framework.h"
37
38 #include <cyg/infra/diag.h>
39
40 #include <lwip/inet.h>
41 #include <lwip/arch.h>
42 #include <lwip/sys.h>
43 #define LWIP_TIMEVAL_PRIVATE 1
44 #include <lwip/sockets.h>
45 #include <cyg/infra/testcase.h>
46
47 #ifndef CYGPKG_LIBC_STDIO
48 #include <cyg/error/errno.h>
49 #define perror(s) diag_printf(#s ": %s\n", strerror(errno))
50 #else
51 #include <stdio.h>
52 #endif
53 #define STACK_SIZE               (CYGNUM_HAL_STACK_SIZE_TYPICAL + 0x1000)
54 #define MAX_LOAD_THREAD_LEVEL    20
55 #define MIN_LOAD_THREAD_LEVEL    0
56 #define NUM_LOAD_THREADS         10
57 #define CYGPKG_NET_THREAD_PRIORITY 7
58 #define IDLE_THREAD_PRIORITY     CYGPKG_NET_THREAD_PRIORITY+3
59 #define LOAD_THREAD_PRIORITY     CYGPKG_NET_THREAD_PRIORITY-1
60 #define MAIN_THREAD_PRIORITY     CYGPKG_NET_THREAD_PRIORITY-2
61 #define DESIRED_BACKGROUND_LOAD  20
62 #define CYGHWR_NET_DRIVERS 1
63
64 #if SO_REUSE
65 #ifdef CYGPKG_LWIP_TCP
66 #ifdef CYGPKG_LWIP_UDP
67
68
69 #if 0
70 static char         main_thread_stack[CYGHWR_NET_DRIVERS][STACK_SIZE];
71 static cyg_thread   main_thread_data[CYGHWR_NET_DRIVERS];
72 static cyg_handle_t main_thread_handle[CYGHWR_NET_DRIVERS];
73 #endif
74
75
76 static char         idle_thread_stack[STACK_SIZE];
77 static cyg_thread   idle_thread_data;
78 static cyg_handle_t idle_thread_handle;
79 static cyg_sem_t    idle_thread_sem;
80 volatile static long long    idle_thread_count;
81 static cyg_tick_count_t idle_thread_start_time;
82 static cyg_tick_count_t idle_thread_stop_time;
83 static char         load_thread_stack[NUM_LOAD_THREADS][STACK_SIZE];
84 static cyg_thread   load_thread_data[NUM_LOAD_THREADS];
85 static cyg_handle_t load_thread_handle[NUM_LOAD_THREADS];
86 static cyg_sem_t    load_thread_sem[NUM_LOAD_THREADS];
87 static long         load_thread_level;
88 static void calibrate_load(int load);
89 static void start_load(int load);
90 static void do_some_random_computation(int p);
91 #define abs(n) ((n) < 0 ? -(n) : (n))
92
93 #define test_param_t cyg_addrword_t
94 #ifdef CYGDBG_NET_TIMING_STATS
95 extern void show_net_times(void);
96 #endif
97
98 #define MAX_BUF 8192
99 static unsigned char in_buf[MAX_BUF], out_buf[MAX_BUF];
100
101 extern void
102 cyg_test_exit(void);
103
104 static void
105 test_delay(int ticks)
106 {
107     cyg_thread_delay(ticks);
108 }
109
110
111 void
112 pexit(char *s)
113 {
114     perror(s);
115 #ifdef CYGDBG_NET_TIMING_STATS
116     show_net_times();
117 #endif
118     cyg_test_exit();
119 }
120
121 //
122 // Generic UDP test
123 //
124
125 static void
126 do_udp_test(int s1, struct nc_request *req, struct sockaddr_in *master)
127 {
128     int i, s, td_len, seq, seq_errors, lost;
129     struct sockaddr_in test_chan_slave, test_chan_master;
130     fd_set fds;
131     struct timeval timeout;
132     struct nc_test_results results;
133     struct nc_test_data *tdp;
134     int nsent, nrecvd;
135     int need_recv, need_send;
136
137     need_recv = true;  need_send = true;
138     switch (ntohl(req->type)) {
139     case NC_REQUEST_UDP_SEND:
140         need_recv = false;
141         need_send = true;
142         break;
143     case NC_REQUEST_UDP_RECV:
144         need_recv = true;
145         need_send = false;
146         break;
147     case NC_REQUEST_UDP_ECHO:
148         break;
149     }
150
151     s = socket(AF_INET, SOCK_DGRAM, 0);
152     if (s < 0) {
153         pexit("datagram socket");
154     }
155
156     memset((char *) &test_chan_slave, 0, sizeof(test_chan_slave));
157     test_chan_slave.sin_family = AF_INET;
158     test_chan_slave.sin_len = sizeof(test_chan_slave);
159     test_chan_slave.sin_addr.s_addr = htonl(INADDR_ANY);
160     test_chan_slave.sin_port = htons(ntohl(req->slave_port));
161     
162     if (bind(s, (struct sockaddr *) &test_chan_slave, sizeof(test_chan_slave)) < 0) {
163         perror("bind");
164         close(s);
165     }
166
167     memcpy(&test_chan_master, master, sizeof(*master));
168     test_chan_master.sin_port = htons(ntohl(req->master_port));
169     nsent = 0;  nrecvd = 0;  seq = 0;  seq_errors = 0;  lost = 0;
170     for (i = 0;  i < ntohl(req->nbufs);  i++) {
171         if (need_recv) {
172             FD_ZERO(&fds);
173             FD_SET(s, &fds);
174             timeout.tv_sec = NC_TEST_TIMEOUT;
175             timeout.tv_usec = 0;
176             if (select(s+1, &fds, 0, 0, &timeout) <= 0) {
177                 test_printf("recvfrom timeout, expecting seq #%d\n", seq);            
178                 if (++lost > MAX_ERRORS) {
179                     test_printf("... giving up\n");
180                     break;
181                 }
182             } else {
183                 nrecvd++;
184                 tdp = (struct nc_test_data *)in_buf;
185                 td_len = ntohl(req->buflen) + sizeof(struct nc_test_data);
186                 if (recvfrom(s, tdp, td_len, 0, 0, 0) < 0) {
187                     perror("recvfrom");
188                     close(s);
189                     return;
190                 }
191                 if ((ntohl(tdp->key1) == NC_TEST_DATA_KEY1) &&
192                     (ntohl(tdp->key2) == NC_TEST_DATA_KEY2)) {
193                     if (ntohl(tdp->seq) != seq) {
194                         test_printf("Packets out of sequence - recvd: %d, expected: %d\n",
195                                     ntohl(tdp->seq), seq);
196                         seq = ntohl(tdp->seq);
197                         seq_errors++;
198                     }
199                 } else {
200                     test_printf("Bad data packet - key: %lx/%lx, seq: %d\n",
201                                 ntohl(tdp->key1), ntohl(tdp->key2),
202                                 ntohl(tdp->seq));
203                 }
204             }
205         }
206         if (need_send) {
207             int retries = 10;
208             int  sent = false;
209             int res;
210
211             tdp = (struct nc_test_data *)out_buf;
212             tdp->key1 = htonl(NC_TEST_DATA_KEY1);
213             tdp->key2 = htonl(NC_TEST_DATA_KEY2);
214             tdp->seq = htonl(seq);
215             td_len = ntohl(req->buflen) + sizeof(struct nc_test_data);
216             tdp->len = htonl(td_len);
217             while (!sent && (--retries >= 0)) {
218                 res = sendto(s, tdp, td_len, 0, 
219                              (struct sockaddr *)&test_chan_master, sizeof(test_chan_master));
220                 if (res > 0) {
221                     sent = true;
222                     break;
223                 }
224                 if (errno == ENOBUFS) {
225                     // Saturated the system
226                     test_delay(1);   // Time for 200 500 byte 10-baseT packets 
227                 } else {
228                     // What else to do?
229                     close(s);
230                     return;
231                 }
232             }
233             if (sent) {
234                 nsent++;
235             } else {
236                 perror("sendto");
237             }
238         }
239         seq++;
240     }
241     results.key1 = htonl(NC_TEST_RESULT_KEY1);
242     results.key2 = htonl(NC_TEST_RESULT_KEY2);
243     results.seq = req->seq;
244     results.nsent = htonl(nsent);
245     results.nrecvd = htonl(nrecvd);
246     if (sendto(s, &results, sizeof(results), 0, 
247                (struct sockaddr *)&test_chan_master, sizeof(test_chan_master)) < 0) {
248         perror("sendto results");
249     }
250     close(s);
251 }
252
253 //
254 // Read data from a stream, accounting for the fact that packet 'boundaries'
255 // are not preserved.  This can also timeout (which would probably wreck the
256 // data boundaries).
257 //
258
259 int
260 do_read(int fd, void *buf, int buflen)
261 {
262     char *p = (char *)buf;
263     int len = buflen;
264     int res;
265     while (len) {
266         res = read(fd, p, len);
267         if (res < 0) {
268             perror("read");
269         } else {
270             len -= res;
271             p += res;
272             if (res == 0) {
273                 break;
274             }
275         }
276     }
277     return (buflen - len);
278 }
279
280 //
281 // Generic TCP test
282 //
283
284 static void
285 do_tcp_test(int s1, struct nc_request *req, struct sockaddr_in *master)
286 {
287     int i, s, len, td_len, seq, seq_errors, lost, test_chan, res;
288     struct sockaddr_in test_chan_slave, test_chan_master;
289     struct nc_test_results results;
290     struct nc_test_data *tdp;
291     int nsent, nrecvd;
292     int need_recv, need_send;
293     int one = 1;
294     static int slave_tcp_port = -1;
295
296     need_recv = true;  need_send = true;
297     switch (ntohl(req->type)) {
298     case NC_REQUEST_TCP_SEND:
299         need_recv = false;
300         need_send = true;
301         break;
302     case NC_REQUEST_TCP_RECV:
303         need_recv = true;
304         need_send = false;
305         break;
306     case NC_REQUEST_TCP_ECHO:
307         break;
308     }
309
310     if (slave_tcp_port < 0) {
311         s = socket(AF_INET, SOCK_STREAM, 0);
312         if (s < 0) {
313             pexit("datagram socket");
314         }
315
316         if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) {
317             perror("setsockopt SO_REUSEADDR");
318             return;
319         }
320 #ifdef SO_REUSEPORT
321         if (setsockopt(s, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one))) {
322             perror("setsockopt SO_REUSEPORT");
323             return;
324         }
325 #endif
326         memset((char *) &test_chan_slave, 0, sizeof(test_chan_slave));
327         test_chan_slave.sin_family = AF_INET;
328         test_chan_slave.sin_len = sizeof(test_chan_slave);
329         test_chan_slave.sin_addr.s_addr = htonl(INADDR_ANY);
330         test_chan_slave.sin_port = htons(ntohl(req->slave_port));
331     
332         if (bind(s, (struct sockaddr *) &test_chan_slave, sizeof(test_chan_slave)) < 0) {
333             perror("bind");
334             close(s);
335         }
336         listen(s, 128);
337         slave_tcp_port = s;
338     }
339
340     s = slave_tcp_port;
341     len = sizeof(test_chan_master);
342     if ((test_chan = accept(s, (struct sockaddr *)&test_chan_master, &len)) < 0) {
343         pexit("accept");
344     }
345     len = sizeof(test_chan_master);
346     getpeername(test_chan, (struct sockaddr *)&test_chan_master, &len);
347 //    test_printf("connection from %s.%d\n", inet_ntoa(test_chan_master.sin_addr), 
348   //              ntohs(test_chan_master.sin_port));
349
350     nsent = 0;  nrecvd = 0;  seq = 0;  seq_errors = 0;  lost = 0;
351     for (i = 0;  i < ntohl(req->nbufs);  i++) {
352         if (need_recv) {
353             tdp = (struct nc_test_data *)in_buf;
354             td_len = ntohl(req->buflen) + sizeof(struct nc_test_data);
355             res = do_read(test_chan, tdp, td_len);
356             if (res != td_len) {
357                 test_printf("recvfrom timeout, expecting seq #%d\n", seq);            
358                 if (++lost > MAX_ERRORS) {
359                     test_printf("... giving up\n");
360                     break;
361                 }
362             } else {
363                 nrecvd++;
364                 if ((ntohl(tdp->key1) == NC_TEST_DATA_KEY1) &&
365                     (ntohl(tdp->key2) == NC_TEST_DATA_KEY2)) {
366                     if (ntohl(tdp->seq) != seq) {
367                         test_printf("Packets out of sequence - recvd: %d, expected: %d\n",
368                                     ntohl(tdp->seq), seq);
369                         seq = ntohl(tdp->seq);
370                         seq_errors++;
371                     }
372                 } else {
373                     test_printf("Bad data packet - key: %lx/%lx, seq: %d\n",
374                                 ntohl(tdp->key1), ntohl(tdp->key2),
375                                 ntohl(tdp->seq));
376                 }
377             }
378         }
379         if (need_send) {
380             tdp = (struct nc_test_data *)out_buf;
381             tdp->key1 = htonl(NC_TEST_DATA_KEY1);
382             tdp->key2 = htonl(NC_TEST_DATA_KEY2);
383             tdp->seq = htonl(seq);
384             td_len = ntohl(req->buflen) + sizeof(struct nc_test_data);
385             tdp->len = htonl(td_len);
386             if (write(test_chan, tdp, td_len) != td_len) {
387                 perror("write");
388                 if (errno == ENOBUFS) {
389                     // Saturated the system
390                     test_delay(25);
391                 } else {
392                     // What else to do?
393                     close(test_chan);
394                     return;
395                 }
396             } else {
397                 nsent++;
398             }
399         }
400         seq++;
401     }
402     results.key1 = htonl(NC_TEST_RESULT_KEY1);
403     results.key2 = htonl(NC_TEST_RESULT_KEY2);
404     results.seq = req->seq;
405     results.nsent = htonl(nsent);
406     results.nrecvd = htonl(nrecvd);
407     if (write(test_chan, &results, sizeof(results)) != sizeof(results)) {
408         perror("write");
409     }
410     close(test_chan);
411 }
412
413 //
414 // Protocol driver for testing slave.
415 //
416 // This function is the main routine running here, handling requests sent from
417 // the master and providing various responses.
418 //
419 static void
420 nc_slave(test_param_t param)
421 {
422     int s, masterlen;
423     struct sockaddr_in my_addr, master;
424     struct nc_request req;
425     struct nc_reply reply;
426     int done = false;
427
428     test_printf("Start test for eth%d\n", param);
429
430     s = socket(AF_INET, SOCK_DGRAM, 0);
431     if (s < 0) {
432         pexit("datagram socket");
433     }
434
435     memset((char *) &my_addr, 0, sizeof(my_addr));
436     my_addr.sin_family = AF_INET;
437     my_addr.sin_len = sizeof(my_addr);
438     my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
439     my_addr.sin_port = htons(NC_SLAVE_PORT);
440     
441     if (bind(s, (struct sockaddr *) &my_addr, sizeof(my_addr)) < 0) {
442         pexit("bind");
443     }
444
445     while (!done) {
446         masterlen = sizeof(master);
447         if (recvfrom(s, &req, sizeof(req), 0, (struct sockaddr *)&master, &masterlen) < 0) {
448             pexit("recvfrom");
449         }
450 #if 0
451         test_printf("Request %d from %s:%d\n", ntohl(req.type), 
452                     inet_ntoa(master.sin_addr), ntohs(master.sin_port));
453 #endif
454         reply.response = htonl(NC_REPLY_ACK);
455         reply.seq = req.seq;
456         switch (ntohl(req.type)) {
457         case NC_REQUEST_DISCONNECT:
458             done = true;
459             break;
460         case NC_REQUEST_UDP_SEND:
461             test_printf("UDP send - %d buffers, %d bytes\n", ntohl(req.nbufs), ntohl(req.buflen));
462             break;
463         case NC_REQUEST_UDP_RECV:
464             test_printf("UDP recv - %d buffers, %d bytes\n", ntohl(req.nbufs), ntohl(req.buflen));
465             break;
466         case NC_REQUEST_UDP_ECHO:
467             test_printf("UDP echo - %d buffers, %d bytes\n", ntohl(req.nbufs), ntohl(req.buflen));
468             break;
469         case NC_REQUEST_TCP_SEND:
470             test_printf("TCP send - %d buffers, %d bytes\n", ntohl(req.nbufs), ntohl(req.buflen));
471             break;
472         case NC_REQUEST_TCP_RECV:
473             test_printf("TCP recv - %d buffers, %d bytes\n", ntohl(req.nbufs), ntohl(req.buflen));
474             break;
475         case NC_REQUEST_TCP_ECHO:
476             test_printf("TCP echo - %d buffers, %d bytes\n", ntohl(req.nbufs), ntohl(req.buflen));
477             break;
478         case NC_REQUEST_SET_LOAD:
479             start_load(ntohl(req.nbufs));
480             break;
481         case NC_REQUEST_START_IDLE:
482             test_printf("Start IDLE thread\n");
483             idle_thread_count = 0;
484             idle_thread_start_time = cyg_current_time();
485             cyg_semaphore_post(&idle_thread_sem);
486             break;
487         case NC_REQUEST_STOP_IDLE:
488             cyg_semaphore_wait(&idle_thread_sem);
489             idle_thread_stop_time = cyg_current_time();
490             test_printf("Stop IDLE thread\n");
491             reply.misc.idle_results.elapsed_time = htonl(idle_thread_stop_time - idle_thread_start_time);
492             reply.misc.idle_results.count[0] = htonl(idle_thread_count >> 32);
493             reply.misc.idle_results.count[1] = htonl((long)idle_thread_count);
494             break;
495         default:
496             test_printf("Unrecognized request: %d\n", ntohl(req.type));
497             reply.response = htonl(NC_REPLY_NAK);
498             reply.reason = htonl(NC_REPLY_NAK_UNKNOWN_REQUEST);
499             break;
500         }
501         if (sendto(s, &reply, sizeof(reply), 0, (struct sockaddr *)&master, masterlen) < 0) {
502             pexit("sendto");
503         }
504         if (reply.response == ntohl(NC_REPLY_NAK)) {
505             continue;
506         }
507         switch (ntohl(req.type)) {
508         case NC_REQUEST_UDP_SEND:
509         case NC_REQUEST_UDP_RECV:
510         case NC_REQUEST_UDP_ECHO:
511             do_udp_test(s, &req, &master);
512             break;
513         case NC_REQUEST_TCP_SEND:
514         case NC_REQUEST_TCP_RECV:
515         case NC_REQUEST_TCP_ECHO:
516             do_tcp_test(s, &req, &master);
517             break;
518         case NC_REQUEST_START_IDLE:
519         case NC_REQUEST_STOP_IDLE:
520         case NC_REQUEST_SET_LOAD:
521         default:
522             break;
523         }
524     }
525     close(s);
526 }
527
528 void
529 net_test(void *arg)
530 {
531     test_param_t param = (test_param_t)arg;
532 //    int i;
533     if (param == 0) {
534         test_printf("Start Network Characterization - SLAVE\n");
535         calibrate_load(DESIRED_BACKGROUND_LOAD);
536     }
537     nc_slave(param);
538 #ifdef CYGDBG_NET_TIMING_STATS
539     show_net_times();
540 #endif
541 #if LWIP_STATS_DISPLAY 
542     stats_display();
543 #endif    
544     cyg_test_exit();
545 }
546
547
548 //
549 // This function is called to calibrate the "background load" which can be
550 // applied during testing.  It will be called before any commands from the
551 // host are managed.
552 //
553 static void
554 calibrate_load(int desired_load)
555 {
556     long long no_load_idle, load_idle;
557     int percent_load;
558     int high, low;
559
560     // Set limits
561     high = MAX_LOAD_THREAD_LEVEL;
562     low = MIN_LOAD_THREAD_LEVEL;
563         test_printf("Start Network Characterization - SLAVE\n");
564
565     // Compute the "no load" idle value
566     idle_thread_count = 0;
567     cyg_semaphore_post(&idle_thread_sem);  // Start idle thread
568         test_printf("Start Network Characterization - SLAVE\n");
569     cyg_thread_delay(1*100);               // Pause for one second
570         test_printf("Start Network Characterization - SLAVE\n");
571     cyg_semaphore_wait(&idle_thread_sem);  // Stop idle thread
572         test_printf("Start Network Characterization - SLAVE\n");
573     no_load_idle = idle_thread_count;
574     diag_printf("No load = %d\n", (int)idle_thread_count);
575
576     // First ensure that the HIGH level is indeed higher
577     while (true) {
578         load_thread_level = high;
579         start_load(desired_load);              // Start up a given load
580         idle_thread_count = 0;
581         cyg_semaphore_post(&idle_thread_sem);  // Start idle thread
582         cyg_thread_delay(1*100);               // Pause for one second
583         cyg_semaphore_wait(&idle_thread_sem);  // Stop idle thread
584         load_idle = idle_thread_count;
585         start_load(0);                         // Shut down background load
586         percent_load = 100 - ((load_idle * 100) / no_load_idle);
587         diag_printf("High Load[%ld] = %d => %d%%\n", load_thread_level, 
588                     (int)idle_thread_count, percent_load);
589         if ( percent_load > desired_load )
590             break; // HIGH level is indeed higher
591         low = load_thread_level; // known to be lower
592         high *= 2; // else double it and try again
593     }
594
595     // Now chop down to the level required
596     while (true) {
597         load_thread_level = (high + low) / 2;
598         start_load(desired_load);              // Start up a given load
599         idle_thread_count = 0;
600         cyg_semaphore_post(&idle_thread_sem);  // Start idle thread
601         cyg_thread_delay(1*100);               // Pause for one second
602         cyg_semaphore_wait(&idle_thread_sem);  // Stop idle thread
603         load_idle = idle_thread_count;
604         start_load(0);                         // Shut down background load
605         percent_load = 100 - ((load_idle * 100) / no_load_idle);
606         diag_printf("Load[%ld] = %d => %d%%\n", load_thread_level, 
607                     (int)idle_thread_count, percent_load);
608         if (((high-low) <= 1) || (abs(desired_load-percent_load) <= 2)) break;
609         if (percent_load < desired_load) {
610             low = load_thread_level;
611         } else {            
612             high = load_thread_level;
613         }
614     }
615
616     // Now we are within a few percent of the target; scale the load
617     // factor to get a better fit, and test it, print the answer.
618     load_thread_level *= desired_load;
619     load_thread_level /= percent_load;
620     start_load(desired_load);              // Start up a given load
621     idle_thread_count = 0;
622     cyg_semaphore_post(&idle_thread_sem);  // Start idle thread
623     cyg_thread_delay(1*100);               // Pause for one second
624     cyg_semaphore_wait(&idle_thread_sem);  // Stop idle thread
625     load_idle = idle_thread_count;
626     start_load(0);                         // Shut down background load
627     percent_load = 100 - ((load_idle * 100) / no_load_idle);
628     diag_printf("Final load[%ld] = %d => %d%%\n", load_thread_level, 
629                 (int)idle_thread_count, percent_load);
630 //    no_load_idle_count_1_second = no_load_idle;
631 }
632
633 //
634 // This function is called to set up a load level of 'load' percent (given
635 // as a whole number, e.g. start_load(20) would mean initiate a background
636 // load of 20%, leaving the cpu 80% idle).
637 //
638 static void
639 start_load(int load)
640 {
641     static int prev_load = 0;
642     int i;
643     test_printf("Set background load = %d%%\n", load);
644     if (load == 0) {
645         if (prev_load == 0) return;  // Nothing out there to stop
646         for (i = 0;  i < prev_load/10;  i++) {
647             cyg_semaphore_wait(&load_thread_sem[i]);
648         }
649         prev_load = 0;
650     } else {
651         for (i = 0;  i < load/10;  i++) {
652             cyg_semaphore_post(&load_thread_sem[i]);
653         }
654         prev_load = load;
655     }
656 }
657
658 //
659 // These thread(s) do some amount of "background" computing.  This is used
660 // to simulate a given load level.  They need to be run at a higher priority 
661 // than the network code itself.
662 //
663 // Like the "idle" thread, they run as long as their "switch" (aka semaphore)
664 // is enabled.
665 //
666 void
667 net_load(cyg_addrword_t who)
668 {
669     int i;
670     while (true) {
671         cyg_semaphore_wait(&load_thread_sem[who]);
672         for (i = 0;  i < load_thread_level;  i++) {
673             do_some_random_computation(i);
674         }
675         cyg_thread_delay(1);  // Wait until the next 'tick'
676         cyg_semaphore_post(&load_thread_sem[who]);
677     }
678 }
679
680 //
681 // Some arbitrary computation, designed to use up the CPU and cause associated
682 // cache "thrash" behaviour - part of background load modelling.
683 //
684 static void
685 do_some_random_computation(int p)
686 {
687     // Just something that might be "hard"
688     volatile double x;
689     x = ((p * 10) * 3.14159) / 180.0;  // radians
690 }
691
692 //
693 // This thread does nothing but count.  It will be allowed to count
694 // as long as the semaphore is "free".  
695 //
696 void
697 net_idle(cyg_addrword_t param)
698 {
699     while (true) {
700         cyg_semaphore_wait(&idle_thread_sem);
701         idle_thread_count++;
702         cyg_semaphore_post(&idle_thread_sem);
703     }
704 }
705 #if 0
706 void
707 cyg_start(void *n)
708 {
709     int i;
710     // Create processing threads
711     for (i = 0;  i < CYGHWR_NET_DRIVERS;  i++) {
712         cyg_thread_create(MAIN_THREAD_PRIORITY,     // Priority
713                           net_test,                 // entry
714                           i,                        // entry parameter
715                           "Network test",           // Name
716                           &main_thread_stack[i][0], // Stack
717                           STACK_SIZE,               // Size
718                           &main_thread_handle[i],   // Handle
719                           &main_thread_data[i]      // Thread data structure
720             );
721     }
722     cyg_thread_resume(main_thread_handle[0]);   // Start first one
723     // Create the idle thread environment
724     cyg_semaphore_init(&idle_thread_sem, 0);
725     cyg_thread_create(IDLE_THREAD_PRIORITY,     // Priority
726                       net_idle,                 // entry
727                       0,                        // entry parameter
728                       "Network idle",           // Name
729                       &idle_thread_stack[0],    // Stack
730                       STACK_SIZE,               // Size
731                       &idle_thread_handle,      // Handle
732                       &idle_thread_data         // Thread data structure
733             );
734     cyg_thread_resume(idle_thread_handle);      // Start it
735     // Create the load threads and their environment(s)
736     for (i = 0;  i < NUM_LOAD_THREADS;  i++) {
737         cyg_semaphore_init(&load_thread_sem[i], 0);
738         cyg_thread_create(LOAD_THREAD_PRIORITY,     // Priority
739                           net_load,                 // entry
740                           i,                        // entry parameter
741                           "Background load",        // Name
742                           &load_thread_stack[i][0], // Stack
743                           STACK_SIZE,               // Size
744                           &load_thread_handle[i],   // Handle
745                           &load_thread_data[i]      // Thread data structure
746             );
747         cyg_thread_resume(load_thread_handle[i]);   // Start it
748     }
749     cyg_scheduler_start();
750 }
751
752 #endif
753
754 void
755 tmain(cyg_addrword_t p)
756 {
757   lwip_init();
758   sys_thread_new(net_test, 0, MAIN_THREAD_PRIORITY);
759 }
760
761 static char stack[STACK_SIZE];
762 static cyg_thread thread_data;
763 static cyg_handle_t thread_handle;
764
765 void
766 nc_slave_main(void)
767 {
768         int i;  
769         
770         CYG_TEST_INIT();
771    // Create the idle thread environment
772     cyg_semaphore_init(&idle_thread_sem, 0);
773     cyg_thread_create(IDLE_THREAD_PRIORITY,     // Priority
774                       net_idle,                 // entry
775                       0,                        // entry parameter
776                       "Network idle",           // Name
777                       &idle_thread_stack[0],    // Stack
778                       STACK_SIZE,               // Size
779                       &idle_thread_handle,      // Handle
780                       &idle_thread_data         // Thread data structure
781             );
782     cyg_thread_resume(idle_thread_handle);      // Start it
783     // Create the load threads and their environment(s)
784     for (i = 0;  i < NUM_LOAD_THREADS;  i++) {
785         cyg_semaphore_init(&load_thread_sem[i], 0);
786         cyg_thread_create(LOAD_THREAD_PRIORITY,     // Priority
787                           net_load,                 // entry
788                           i,                        // entry parameter
789                           "Background load",        // Name
790                           &load_thread_stack[i][0], // Stack
791                           STACK_SIZE,               // Size
792                           &load_thread_handle[i],   // Handle
793                           &load_thread_data[i]      // Thread data structure
794             );
795         cyg_thread_resume(load_thread_handle[i]);   // Start it
796     }
797     // Create a main thread, so we can run the scheduler and have time 'pass'
798     cyg_thread_create(10,                // Priority - just a number
799                       tmain,          // entry
800                       0,                 // entry parameter
801                       "socket echo test",        // Name
802                       &stack[0],         // Stack
803                       STACK_SIZE,        // Size
804                       &thread_handle,    // Handle
805                       &thread_data       // Thread data structure
806             );
807     cyg_thread_resume(thread_handle);  // Start it
808     cyg_scheduler_start();
809     CYG_TEST_FAIL_FINISH("Not reached");
810 }
811
812
813 externC void
814 cyg_start( void )
815 {
816     nc_slave_main();
817 }
818
819 #else // def CYGPKG_LWIP_UDP
820 #define N_A_MSG "UDP support disabled"
821 #endif // def CYGPKG_LWIP_UDP
822 #else // def CYGPKG_LWIP_TCP
823 #define N_A_MSG "TCP support disabled"
824 #endif // def CYGPKG_LWIP_TCP
825 #else // SO_REUSE
826 #define N_A_MSG "SO_REUSE currently unavailable"
827 #endif // SO_REUSE
828
829 #ifdef N_A_MSG
830 externC void
831 cyg_start( void )
832 {
833     CYG_TEST_INIT();
834     CYG_TEST_NA(N_A_MSG);
835 }
836 #endif // N_A_MSG