unified MX27, MX25, MX37 trees
[karo-tx-redboot.git] / packages / kernel / v2_0 / tests / tm_basic.cxx
1 //==========================================================================
2 //
3 //        tm_basic.cxx
4 //
5 //        Basic timing test / scaffolding
6 //
7 //==========================================================================
8 //####ECOSGPLCOPYRIGHTBEGIN####
9 // -------------------------------------------
10 // This file is part of eCos, the Embedded Configurable Operating System.
11 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
12 // Copyright (C) 2002, 2003 Gary Thomas
13 //
14 // eCos is free software; you can redistribute it and/or modify it under
15 // the terms of the GNU General Public License as published by the Free
16 // Software Foundation; either version 2 or (at your option) any later version.
17 //
18 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
19 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
20 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
21 // for more details.
22 //
23 // You should have received a copy of the GNU General Public License along
24 // with eCos; if not, write to the Free Software Foundation, Inc.,
25 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
26 //
27 // As a special exception, if other files instantiate templates or use macros
28 // or inline functions from this file, or you compile this file and link it
29 // with other works to produce a work based on this file, this file does not
30 // by itself cause the resulting work to be covered by the GNU General Public
31 // License. However the source code for this file must still be made available
32 // in accordance with section (3) of the GNU General Public License.
33 //
34 // This exception does not invalidate any other reasons why a work based on
35 // this file might be covered by the GNU General Public License.
36 //
37 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
38 // at http://sources.redhat.com/ecos/ecos-license/
39 // -------------------------------------------
40 //####ECOSGPLCOPYRIGHTEND####
41 //==========================================================================
42 //#####DESCRIPTIONBEGIN####
43 //
44 // Author(s):     gthomas
45 // Contributors:  gthomas
46 // Date:          1998-10-19
47 // Description:   Very simple kernel timing test
48 //####DESCRIPTIONEND####
49
50 #include <pkgconf/kernel.h>
51 #include <pkgconf/hal.h>
52
53 #include <cyg/kernel/sched.hxx>
54 #include <cyg/kernel/thread.hxx>
55 #include <cyg/kernel/thread.inl>
56 #include <cyg/kernel/mutex.hxx>
57 #include <cyg/kernel/sema.hxx>
58 #include <cyg/kernel/flag.hxx>
59 #include <cyg/kernel/sched.inl>
60 #include <cyg/kernel/clock.hxx>
61 #include <cyg/kernel/clock.inl>
62 #include <cyg/kernel/kapi.h>
63
64 #include <cyg/infra/testcase.h>
65 #include <cyg/infra/diag.h>
66
67 #include <cyg/kernel/test/stackmon.h>
68 #include CYGHWR_MEMORY_LAYOUT_H
69
70 // Define this to see the statistics with the first sample datum removed.
71 // This can expose the effects of caches on the speed of operations.
72 #undef STATS_WITHOUT_FIRST_SAMPLE
73
74 #if defined(CYGFUN_KERNEL_API_C) &&             \
75     defined(CYGSEM_KERNEL_SCHED_MLQUEUE) &&     \
76     defined(CYGVAR_KERNEL_COUNTERS_CLOCK) &&    \
77     !defined(CYGDBG_INFRA_DIAG_USE_DEVICE) &&   \
78     (CYGNUM_KERNEL_SCHED_PRIORITIES > 12)
79
80 #define NTHREADS 1
81 #include "testaux.hxx"
82
83 // Structure used to keep track of times
84 typedef struct fun_times {
85     cyg_uint32 start;
86     cyg_uint32 end;
87 } fun_times;
88
89 #define STACK_SIZE (CYGNUM_HAL_STACK_SIZE_TYPICAL+4*1024)
90
91 #ifdef CYGMEM_REGION_ram_SIZE
92 #define CYG_THREAD_OVERHEAD  (STACK_SIZE+sizeof(cyg_thread)+(sizeof(fun_times)*2))
93 #define NTEST_THREADS        ((CYGMEM_REGION_ram_SIZE/16)/CYG_THREAD_OVERHEAD)
94 #define CYG_MUTEX_OVERHEAD   (sizeof(cyg_mutex_t)+sizeof(fun_times))
95 #define NMUTEXES             ((CYGMEM_REGION_ram_SIZE/16)/CYG_MUTEX_OVERHEAD)
96 #define CYG_MBOX_OVERHEAD    (sizeof(cyg_mbox)+sizeof(fun_times))
97 #define NMBOXES              ((CYGMEM_REGION_ram_SIZE/24)/CYG_MBOX_OVERHEAD)
98 #define CYG_SEMAPHORE_OVERHEAD (sizeof(cyg_sem_t)+sizeof(fun_times))
99 #define NSEMAPHORES          ((CYGMEM_REGION_ram_SIZE/16)/CYG_SEMAPHORE_OVERHEAD)
100 #define CYG_COUNTER_OVERHEAD (sizeof(cyg_counter)+sizeof(fun_times))
101 #define NCOUNTERS            ((CYGMEM_REGION_ram_SIZE/24)/CYG_COUNTER_OVERHEAD)
102 #define CYG_FLAG_OVERHEAD    (sizeof(cyg_flag_t)+sizeof(fun_times))
103 #define NFLAGS               ((CYGMEM_REGION_ram_SIZE/24)/CYG_FLAG_OVERHEAD)
104 #define CYG_ALARM_OVERHEAD   (sizeof(cyg_alarm)+sizeof(fun_times))
105 #define NALARMS              ((CYGMEM_REGION_ram_SIZE/16)/CYG_ALARM_OVERHEAD)
106 #else
107 // Defaults
108 #define NTEST_THREADS    16
109 #define NMUTEXES         32
110 #define NMBOXES          32
111 #define NSEMAPHORES      32
112 #define NFLAGS           32
113 #define NCOUNTERS        32
114 #define NALARMS          32
115 #endif
116
117 #define NSAMPLES         32
118 #define NTHREAD_SWITCHES 128
119 #define NSCHEDS          128
120
121 #define NSAMPLES_SIM         2
122 #define NTEST_THREADS_SIM    2
123 #define NTHREAD_SWITCHES_SIM 4
124 #define NMUTEXES_SIM         2
125 #define NMBOXES_SIM          2
126 #define NSEMAPHORES_SIM      2
127 #define NSCHEDS_SIM          4
128 #define NFLAGS_SIM           2
129 #define NCOUNTERS_SIM        2
130 #define NALARMS_SIM          2
131
132 static int nsamples;
133 static int ntest_threads;
134 static int nthread_switches;
135 static int nmutexes;
136 static int nmboxes;
137 static int nsemaphores;
138 static int nscheds;
139 static int nflags;
140 static int ncounters;
141 static int nalarms;
142
143 static char stacks[NTEST_THREADS][STACK_SIZE];
144 static cyg_thread test_threads[NTEST_THREADS];
145 static cyg_handle_t threads[NTEST_THREADS];
146 static int overhead;
147 static cyg_sem_t synchro;
148 static fun_times thread_ft[NTEST_THREADS];
149
150 static fun_times test2_ft[NTHREAD_SWITCHES];
151
152 static cyg_mutex_t test_mutexes[NMUTEXES];
153 static fun_times mutex_ft[NMUTEXES];
154 static cyg_thread mutex_test_thread;
155 static cyg_handle_t mutex_test_thread_handle;
156
157 static cyg_mbox test_mboxes[NMBOXES];
158 static cyg_handle_t test_mbox_handles[NMBOXES];
159 static fun_times mbox_ft[NMBOXES];
160 #ifdef CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT
161 static cyg_thread mbox_test_thread;
162 static cyg_handle_t mbox_test_thread_handle;
163 #endif
164
165 static cyg_sem_t test_semaphores[NSEMAPHORES];
166 static fun_times semaphore_ft[NSEMAPHORES];
167 static cyg_thread semaphore_test_thread;
168 static cyg_handle_t semaphore_test_thread_handle;
169
170 static fun_times sched_ft[NSCHEDS];
171
172 static cyg_counter test_counters[NCOUNTERS];
173 static cyg_handle_t counters[NCOUNTERS];
174 static fun_times counter_ft[NCOUNTERS];
175
176 static cyg_flag_t test_flags[NFLAGS];
177 static fun_times flag_ft[NFLAGS];
178
179 static cyg_alarm test_alarms[NALARMS];
180 static cyg_handle_t alarms[NALARMS];
181 static fun_times alarm_ft[NALARMS];
182
183 static long rtc_resolution[] = CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION;
184 static long ns_per_system_clock;
185
186 #if defined(CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY)  && defined(HAL_CLOCK_LATENCY)
187 // Data kept by kernel real time clock measuring clock interrupt latency
188 extern cyg_tick_count total_clock_latency, total_clock_interrupts;
189 extern cyg_int32 min_clock_latency, max_clock_latency;
190 extern bool measure_clock_latency;
191 #endif
192
193 #if defined(CYGVAR_KERNEL_COUNTERS_CLOCK_DSR_LATENCY) && defined(HAL_CLOCK_LATENCY)
194 extern cyg_tick_count total_clock_dsr_latency, total_clock_dsr_calls;
195 extern cyg_int32 min_clock_dsr_latency, max_clock_dsr_latency;
196 extern bool measure_clock_latency;
197 #endif
198
199 void run_sched_tests(void);
200 void run_thread_tests(void);
201 void run_thread_switch_test(void);
202 void run_mutex_tests(void);
203 void run_mutex_circuit_test(void);
204 void run_mbox_tests(void);
205 void run_mbox_circuit_test(void);
206 void run_semaphore_tests(void);
207 void run_semaphore_circuit_test(void);
208 void run_counter_tests(void);
209 void run_flag_tests(void);
210 void run_alarm_tests(void);
211
212 #ifndef max
213 #define max(n,m) (m > n ? n : m)
214 #endif
215
216 // Wait until a clock tick [real time clock] has passed.  This should keep it
217 // from happening again during a measurement, thus minimizing any fluctuations
218 void
219 wait_for_tick(void)
220 {
221     cyg_tick_count_t tv0, tv1;
222     tv0 = cyg_current_time();
223     while (true) {
224         tv1 = cyg_current_time();
225         if (tv1 != tv0) break;
226     }
227 }
228
229 // Display a number of ticks as microseconds
230 // Note: for improved calculation significance, values are kept in ticks*1000
231 void
232 show_ticks_in_us(cyg_uint32 ticks)
233 {
234     long long ns;
235     ns = (ns_per_system_clock * (long long)ticks) / CYGNUM_KERNEL_COUNTERS_RTC_PERIOD;
236     ns += 5;  // for rounding to .01us
237     diag_printf("%5d.%02d", (int)(ns/1000), (int)((ns%1000)/10));
238 }
239
240 //
241 // If the kernel is instrumented to measure clock interrupt latency, these
242 // measurements can be drastically perturbed by printing via "diag_printf()"
243 // since that code may run with interrupts disabled for long periods.
244 //
245 // In order to get accurate/reasonable latency figures _for the kernel 
246 // primitive functions beint tested_, the kernel's latency measurements
247 // are suspended while the printing actually takes place.
248 //
249 // The measurements are reenabled after the printing, thus allowing for
250 // fair measurements of the kernel primitives, which are not distorted
251 // by the printing mechanisms.
252
253 #if defined(CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY) && defined(HAL_CLOCK_LATENCY)
254 void
255 disable_clock_latency_measurement(void)
256 {
257     wait_for_tick();
258     measure_clock_latency = false;
259 }
260
261 void
262 enable_clock_latency_measurement(void)
263 {
264     wait_for_tick();
265     measure_clock_latency = true;
266 }
267
268 // Ensure that the measurements are reasonable (no startup anomalies)
269 void
270 reset_clock_latency_measurement(void)
271 {
272   disable_clock_latency_measurement();
273   total_clock_latency = 0;
274   total_clock_interrupts = 0;
275   min_clock_latency = 0x7FFFFFFF;
276   max_clock_latency = 0;
277 #if defined(CYGVAR_KERNEL_COUNTERS_CLOCK_DSR_LATENCY) && defined(HAL_CLOCK_LATENCY)
278   total_clock_dsr_latency = 0;
279   total_clock_dsr_calls = 0;
280   min_clock_dsr_latency = 0x7FFFFFFF;
281   max_clock_dsr_latency = 0;
282 #endif  
283   enable_clock_latency_measurement();
284   
285 }
286 #else
287 #define disable_clock_latency_measurement()
288 #define enable_clock_latency_measurement()
289 #define reset_clock_latency_measurement()
290 #endif
291
292 void
293 show_times_hdr(void)
294 {
295     disable_clock_latency_measurement();
296     diag_printf("\n");
297     diag_printf("                                 Confidence\n");
298     diag_printf("     Ave     Min     Max     Var  Ave  Min  Function\n");
299     diag_printf("  ======  ======  ======  ====== ========== ========\n");
300     enable_clock_latency_measurement();
301 }
302
303 void
304 show_times_detail(fun_times ft[], int nsamples, char *title, bool ignore_first)
305 {
306     int i, delta, min, max, con_ave, con_min, ave_dev;
307     int start_sample, total_samples;   
308     cyg_int32 total, ave;
309
310     if (ignore_first) {
311         start_sample = 1;
312         total_samples = nsamples-1;
313     } else {
314         start_sample = 0;
315         total_samples = nsamples;
316     }
317     total = 0;
318     min = 0x7FFFFFFF;
319     max = 0;
320     for (i = start_sample;  i < nsamples;  i++) {
321         if (ft[i].end < ft[i].start) {
322             // Clock wrapped around (timer tick)
323             delta = (ft[i].end+CYGNUM_KERNEL_COUNTERS_RTC_PERIOD) - ft[i].start;
324         } else {
325             delta = ft[i].end - ft[i].start;
326         }
327         delta -= overhead;
328         if (delta < 0) delta = 0;
329         delta *= 1000;
330         total += delta;
331         if (delta < min) min = delta;
332         if (delta > max) max = delta;
333     }
334     ave = total / total_samples;
335     total = 0;
336     ave_dev = 0;
337     for (i = start_sample;  i < nsamples;  i++) {
338         if (ft[i].end < ft[i].start) {
339             // Clock wrapped around (timer tick)
340             delta = (ft[i].end+CYGNUM_KERNEL_COUNTERS_RTC_PERIOD) - ft[i].start;
341         } else {
342             delta = ft[i].end - ft[i].start;
343         }
344         delta -= overhead;
345         if (delta < 0) delta = 0;
346         delta *= 1000;
347         delta = delta - ave;
348         if (delta < 0) delta = -delta;
349         ave_dev += delta;
350     }
351     ave_dev /= total_samples;
352     con_ave = 0;
353     con_min = 0;
354     for (i = start_sample;  i < nsamples;  i++) {
355         if (ft[i].end < ft[i].start) {
356             // Clock wrapped around (timer tick)
357             delta = (ft[i].end+CYGNUM_KERNEL_COUNTERS_RTC_PERIOD) - ft[i].start;
358         } else {
359             delta = ft[i].end - ft[i].start;
360         }
361         delta -= overhead;
362         if (delta < 0) delta = 0;
363         delta *= 1000;
364         if ((delta <= (ave+ave_dev)) && (delta >= (ave-ave_dev))) con_ave++;
365         if ((delta <= (min+ave_dev)) && (delta >= (min-ave_dev))) con_min++;
366     }
367     con_ave = (con_ave * 100) / total_samples;
368     con_min = (con_min * 100) / total_samples;
369     show_ticks_in_us(ave);
370     show_ticks_in_us(min);
371     show_ticks_in_us(max);
372     show_ticks_in_us(ave_dev);
373     disable_clock_latency_measurement();
374     diag_printf("  %3d%% %3d%%", con_ave, con_min);
375     diag_printf(" %s\n", title);
376     enable_clock_latency_measurement();
377 }
378
379 void
380 show_times(fun_times ft[], int nsamples, char *title)
381 {
382     show_times_detail(ft, nsamples, title, false);
383 #ifdef STATS_WITHOUT_FIRST_SAMPLE
384     show_times_detail(ft, nsamples, "", true);
385 #endif
386 }
387
388 void
389 show_test_parameters(void)
390 {
391     disable_clock_latency_measurement();
392     diag_printf("\nTesting parameters:\n");
393     diag_printf("   Clock samples:         %5d\n", nsamples);
394     diag_printf("   Threads:               %5d\n", ntest_threads);
395     diag_printf("   Thread switches:       %5d\n", nthread_switches);
396     diag_printf("   Mutexes:               %5d\n", nmutexes);
397     diag_printf("   Mailboxes:             %5d\n", nmboxes);
398     diag_printf("   Semaphores:            %5d\n", nsemaphores);
399     diag_printf("   Scheduler operations:  %5d\n", nscheds);
400     diag_printf("   Counters:              %5d\n", ncounters);
401     diag_printf("   Flags:                 %5d\n", nflags);
402     diag_printf("   Alarms:                %5d\n", nalarms);
403     diag_printf("\n"); 
404     enable_clock_latency_measurement();
405 }
406
407 void
408 end_of_test_group(void)
409 {
410     disable_clock_latency_measurement();
411     diag_printf("\n"); 
412     enable_clock_latency_measurement();
413 }
414
415 // Compute a name for a thread
416 char *
417 thread_name(char *basename, int indx) {
418     return "<<NULL>>";  // Not currently used
419 }
420
421 // test0 - null test, never executed
422 void
423 test0(cyg_uint32 indx)
424 {
425 #ifndef CYGPKG_KERNEL_SMP_SUPPORT
426     // In SMP, somw of these threads will execute
427     diag_printf("test0.%d executed?\n", indx);
428 #endif    
429     cyg_thread_exit();
430 }
431
432 // test1 - empty test, simply exit.  Last thread signals parent.
433 void
434 test1(cyg_uint32 indx)
435 {
436     if (indx == (cyg_uint32)(ntest_threads-1)) {
437         cyg_semaphore_post(&synchro);  // Signal that last thread is dying
438     }
439     cyg_thread_exit();
440 }
441
442 // test2 - measure thread switch times
443 void
444 test2(cyg_uint32 indx)
445 {
446     int i;
447     for (i = 0;  i < nthread_switches;  i++) {
448         if (indx == 0) {
449             HAL_CLOCK_READ(&test2_ft[i].start);
450         } else {
451             HAL_CLOCK_READ(&test2_ft[i].end);
452         }
453         cyg_thread_yield();
454     }
455     if (indx == 1) {
456         cyg_semaphore_post(&synchro);
457     }
458     cyg_thread_exit();
459 }
460
461 // Full-circuit mutex unlock/lock test
462 void
463 mutex_test(cyg_uint32 indx)
464 {
465     int i;
466     cyg_mutex_lock(&test_mutexes[0]);
467     for (i = 0;  i < nmutexes;  i++) {
468         cyg_semaphore_wait(&synchro);
469         wait_for_tick(); // Wait until the next clock tick to minimize aberations
470         HAL_CLOCK_READ(&mutex_ft[i].start);
471         cyg_mutex_unlock(&test_mutexes[0]);
472         cyg_mutex_lock(&test_mutexes[0]);
473         cyg_semaphore_post(&synchro);
474     }
475     cyg_thread_exit();
476 }
477
478 // Full-circuit mbox put/get test
479 void
480 mbox_test(cyg_uint32 indx)
481 {
482     void *item;
483     do {
484         item = cyg_mbox_get(test_mbox_handles[0]);
485         HAL_CLOCK_READ(&mbox_ft[(int)item].end);
486         cyg_semaphore_post(&synchro);
487     } while ((int)item != (nmboxes-1));
488     cyg_thread_exit();
489 }
490
491 // Full-circuit semaphore post/wait test
492 void
493 semaphore_test(cyg_uint32 indx)
494 {
495     int i;
496     for (i = 0;  i < nsemaphores;  i++) {
497         cyg_semaphore_wait(&test_semaphores[0]);
498         HAL_CLOCK_READ(&semaphore_ft[i].end);
499         cyg_semaphore_post(&synchro);
500     }
501     cyg_thread_exit();
502 }
503
504 //
505 // This set of tests is used to measure kernel primitives that deal with threads
506 //
507 void
508 run_thread_tests(void)
509 {
510     int i;
511     cyg_priority_t prio;
512
513     // Set my priority higher than any I plan to create
514     cyg_thread_set_priority(cyg_thread_self(), 2);
515
516     wait_for_tick(); // Wait until the next clock tick to minimize aberations
517     for (i = 0;  i < ntest_threads;  i++) {
518         HAL_CLOCK_READ(&thread_ft[i].start);
519         cyg_thread_create(10,              // Priority - just a number
520                           test0,           // entry
521                           i,               // index
522                           thread_name("thread", i),     // Name
523                           &stacks[i][0],   // Stack
524                           STACK_SIZE,      // Size
525                           &threads[i],     // Handle
526                           &test_threads[i] // Thread data structure
527             );
528         HAL_CLOCK_READ(&thread_ft[i].end);
529     }
530     show_times(thread_ft, ntest_threads, "Create thread");
531
532     wait_for_tick(); // Wait until the next clock tick to minimize aberations
533     for (i = 0;  i < ntest_threads;  i++) {
534         HAL_CLOCK_READ(&thread_ft[i].start);
535         cyg_thread_yield();
536         HAL_CLOCK_READ(&thread_ft[i].end);
537     }
538     show_times(thread_ft, ntest_threads, "Yield thread [all suspended]");
539
540     wait_for_tick(); // Wait until the next clock tick to minimize aberations
541     for (i = 0;  i < ntest_threads;  i++) {
542         HAL_CLOCK_READ(&thread_ft[i].start);
543         cyg_thread_suspend(threads[i]);
544         HAL_CLOCK_READ(&thread_ft[i].end);
545     }
546     show_times(thread_ft, ntest_threads, "Suspend [suspended] thread");
547
548     wait_for_tick(); // Wait until the next clock tick to minimize aberations
549     for (i = 0;  i < ntest_threads;  i++) {
550         HAL_CLOCK_READ(&thread_ft[i].start);
551         cyg_thread_resume(threads[i]);
552         HAL_CLOCK_READ(&thread_ft[i].end);
553     }
554     show_times(thread_ft, ntest_threads, "Resume thread");
555
556     wait_for_tick(); // Wait until the next clock tick to minimize aberations
557     for (i = 0;  i < ntest_threads;  i++) {
558         HAL_CLOCK_READ(&thread_ft[i].start);
559         cyg_thread_set_priority(threads[i], 11);
560         HAL_CLOCK_READ(&thread_ft[i].end);
561     }
562     show_times(thread_ft, ntest_threads, "Set priority");
563
564     wait_for_tick(); // Wait until the next clock tick to minimize aberations
565     for (i = 0;  i < ntest_threads;  i++) {
566         HAL_CLOCK_READ(&thread_ft[i].start);
567         prio = cyg_thread_get_priority(threads[i]);
568         HAL_CLOCK_READ(&thread_ft[i].end);
569     }
570     show_times(thread_ft, ntest_threads, "Get priority");
571
572     wait_for_tick(); // Wait until the next clock tick to minimize aberations
573     for (i = 0;  i < ntest_threads;  i++) {
574         HAL_CLOCK_READ(&thread_ft[i].start);
575         cyg_thread_kill(threads[i]);
576         HAL_CLOCK_READ(&thread_ft[i].end);
577     }
578     show_times(thread_ft, ntest_threads, "Kill [suspended] thread");
579
580     wait_for_tick(); // Wait until the next clock tick to minimize aberations
581     for (i = 0;  i < ntest_threads;  i++) {
582         HAL_CLOCK_READ(&thread_ft[i].start);
583         cyg_thread_yield();
584         HAL_CLOCK_READ(&thread_ft[i].end);
585     }
586     show_times(thread_ft, ntest_threads, "Yield [no other] thread");
587
588     // Set my priority higher than any I plan to create
589     cyg_thread_set_priority(cyg_thread_self(), 2);
590
591     // Recreate the test set
592     for (i = 0;  i < ntest_threads;  i++) {
593         cyg_thread_create(10,              // Priority - just a number
594                           test0,           // entry
595                           i,               // index
596                           thread_name("thread", i),     // Name
597                           &stacks[i][0],   // Stack
598                           STACK_SIZE,      // Size
599                           &threads[i],     // Handle
600                           &test_threads[i] // Thread data structure
601             );
602     }
603
604     wait_for_tick(); // Wait until the next clock tick to minimize aberations
605     for (i = 0;  i < ntest_threads;  i++) {
606         HAL_CLOCK_READ(&thread_ft[i].start);
607         cyg_thread_resume(threads[i]);
608         HAL_CLOCK_READ(&thread_ft[i].end);
609     }
610     show_times(thread_ft, ntest_threads, "Resume [suspended low prio] thread");
611
612     wait_for_tick(); // Wait until the next clock tick to minimize aberations
613     for (i = 0;  i < ntest_threads;  i++) {
614         HAL_CLOCK_READ(&thread_ft[i].start);
615         cyg_thread_resume(threads[i]);
616         HAL_CLOCK_READ(&thread_ft[i].end);
617     }
618     show_times(thread_ft, ntest_threads, "Resume [runnable low prio] thread");
619
620     wait_for_tick(); // Wait until the next clock tick to minimize aberations
621     for (i = 0;  i < ntest_threads;  i++) {
622         HAL_CLOCK_READ(&thread_ft[i].start);
623         cyg_thread_suspend(threads[i]);
624         HAL_CLOCK_READ(&thread_ft[i].end);
625     }
626     show_times(thread_ft, ntest_threads, "Suspend [runnable] thread");
627
628
629     wait_for_tick(); // Wait until the next clock tick to minimize aberations
630     for (i = 0;  i < ntest_threads;  i++) {
631         HAL_CLOCK_READ(&thread_ft[i].start);
632         cyg_thread_yield();
633         HAL_CLOCK_READ(&thread_ft[i].end);
634     }
635     show_times(thread_ft, ntest_threads, "Yield [only low prio] thread");
636
637     wait_for_tick(); // Wait until the next clock tick to minimize aberations
638     for (i = 0;  i < ntest_threads;  i++) {
639         HAL_CLOCK_READ(&thread_ft[i].start);
640         cyg_thread_suspend(threads[i]);
641         HAL_CLOCK_READ(&thread_ft[i].end);
642     }
643     show_times(thread_ft, ntest_threads, "Suspend [runnable->not runnable]");
644     for (i = 0;  i < ntest_threads;  i++) {
645         cyg_thread_resume(threads[i]);
646     }
647
648     wait_for_tick(); // Wait until the next clock tick to minimize aberations
649     for (i = 0;  i < ntest_threads;  i++) {
650         HAL_CLOCK_READ(&thread_ft[i].start);
651         cyg_thread_kill(threads[i]);
652         HAL_CLOCK_READ(&thread_ft[i].end);
653     }
654     show_times(thread_ft, ntest_threads, "Kill [runnable] thread");
655
656     wait_for_tick(); // Wait until the next clock tick to minimize aberations
657     for (i = 0;  i < ntest_threads;  i++) {
658         HAL_CLOCK_READ(&thread_ft[i].start);
659         cyg_thread_delete(threads[i]);
660         HAL_CLOCK_READ(&thread_ft[i].end);
661     }
662     show_times(thread_ft, ntest_threads, "Destroy [dead] thread");
663
664     // Recreate the test set
665     for (i = 0;  i < ntest_threads;  i++) {
666         cyg_thread_create(10,              // Priority - just a number
667                           test0,           // entry
668                           i,               // index
669                           thread_name("thread", i),     // Name
670                           &stacks[i][0],   // Stack
671                           STACK_SIZE,      // Size
672                           &threads[i],     // Handle
673                           &test_threads[i] // Thread data structure
674             );
675         cyg_thread_resume(threads[i]);
676     }
677
678     wait_for_tick(); // Wait until the next clock tick to minimize aberations
679     for (i = 0;  i < ntest_threads;  i++) {
680         HAL_CLOCK_READ(&thread_ft[i].start);
681         cyg_thread_delete(threads[i]);
682         HAL_CLOCK_READ(&thread_ft[i].end);
683     }
684     show_times(thread_ft, ntest_threads, "Destroy [runnable] thread");
685
686     // Set my priority lower than any I plan to create
687     cyg_thread_set_priority(cyg_thread_self(), 3);
688
689     // Set up the end-of-threads synchronizer
690     cyg_semaphore_init(&synchro, 0);
691
692     // Recreate the test set
693     for (i = 0;  i < ntest_threads;  i++) {
694         cyg_thread_create(2,               // Priority - just a number
695                           test1,           // entry
696                           i,               // index
697                           thread_name("thread", i),     // Name
698                           &stacks[i][0],   // Stack
699                           STACK_SIZE,      // Size
700                           &threads[i],     // Handle
701                           &test_threads[i] // Thread data structure
702             );
703     }
704
705     wait_for_tick(); // Wait until the next clock tick to minimize aberations
706     for (i = 0;  i < ntest_threads;  i++) {
707         HAL_CLOCK_READ(&thread_ft[i].start);
708         cyg_thread_resume(threads[i]);
709         HAL_CLOCK_READ(&thread_ft[i].end);
710     }
711     show_times(thread_ft, ntest_threads, "Resume [high priority] thread");
712     cyg_semaphore_wait(&synchro);  // Wait for all threads to finish
713     // Make sure they are all dead
714     for (i = 0;  i < ntest_threads;  i++) {
715         cyg_thread_delete(threads[i]);
716     }
717
718     run_thread_switch_test();
719     end_of_test_group();
720 }
721
722 void
723 run_thread_switch_test(void)
724 {
725     int i;
726
727     // Set up for thread context switch 
728     for (i = 0;  i < 2;  i++) {
729         cyg_thread_create(10,              // Priority - just a number
730                           test2,           // entry
731                           i,               // index
732                           thread_name("thread", i),     // Name
733                           &stacks[i][0],   // Stack
734                           STACK_SIZE,      // Size
735                           &threads[i],     // Handle
736                           &test_threads[i] // Thread data structure
737             );
738         cyg_thread_resume(threads[i]);
739     }
740     // Set up the end-of-threads synchronizer
741     cyg_semaphore_init(&synchro, 0);
742     cyg_semaphore_wait(&synchro);
743     wait_for_tick(); // Wait until the next clock tick to minimize aberations
744     show_times(test2_ft, nthread_switches, "Thread switch");
745     // Clean up
746     for (i = 0;  i < 2;  i++) {
747         cyg_thread_delete(threads[i]);
748     }
749 }
750
751 void
752 run_mutex_tests(void)
753 {
754     int i;
755
756     // Mutex primitives
757     wait_for_tick(); // Wait until the next clock tick to minimize aberations
758     for (i = 0;  i < nmutexes;  i++) {
759         HAL_CLOCK_READ(&mutex_ft[i].start);
760         cyg_mutex_init(&test_mutexes[i]);
761         HAL_CLOCK_READ(&mutex_ft[i].end);
762     }
763     show_times(mutex_ft, nmutexes, "Init mutex");
764
765     wait_for_tick(); // Wait until the next clock tick to minimize aberations
766     for (i = 0;  i < nmutexes;  i++) {
767         HAL_CLOCK_READ(&mutex_ft[i].start);
768         cyg_mutex_lock(&test_mutexes[i]);
769         HAL_CLOCK_READ(&mutex_ft[i].end);
770     }
771     show_times(mutex_ft, nmutexes, "Lock [unlocked] mutex");
772
773     wait_for_tick(); // Wait until the next clock tick to minimize aberations
774     for (i = 0;  i < nmutexes;  i++) {
775         HAL_CLOCK_READ(&mutex_ft[i].start);
776         cyg_mutex_unlock(&test_mutexes[i]);
777         HAL_CLOCK_READ(&mutex_ft[i].end);
778     }
779     show_times(mutex_ft, nmutexes, "Unlock [locked] mutex");
780
781     wait_for_tick(); // Wait until the next clock tick to minimize aberations
782     for (i = 0;  i < nmutexes;  i++) {
783         HAL_CLOCK_READ(&mutex_ft[i].start);
784         cyg_mutex_trylock(&test_mutexes[i]);
785         HAL_CLOCK_READ(&mutex_ft[i].end);
786     }
787     show_times(mutex_ft, nmutexes, "Trylock [unlocked] mutex");
788
789     wait_for_tick(); // Wait until the next clock tick to minimize aberations
790     for (i = 0;  i < nmutexes;  i++) {
791         HAL_CLOCK_READ(&mutex_ft[i].start);
792         cyg_mutex_trylock(&test_mutexes[i]);
793         HAL_CLOCK_READ(&mutex_ft[i].end);
794     }
795     show_times(mutex_ft, nmutexes, "Trylock [locked] mutex");
796
797     // Must unlock mutices before destroying them.
798     for (i = 0;  i < nmutexes;  i++) {
799         cyg_mutex_unlock(&test_mutexes[i]);
800     }
801
802     wait_for_tick(); // Wait until the next clock tick to minimize aberations
803     for (i = 0;  i < nmutexes;  i++) {
804         HAL_CLOCK_READ(&mutex_ft[i].start);
805         cyg_mutex_destroy(&test_mutexes[i]);
806         HAL_CLOCK_READ(&mutex_ft[i].end);
807     }
808     show_times(mutex_ft, nmutexes, "Destroy mutex");
809     run_mutex_circuit_test();
810     end_of_test_group();
811 }
812
813 void
814 run_mutex_circuit_test(void)
815 {
816     int i;
817     // Set my priority lower than any I plan to create
818     cyg_thread_set_priority(cyg_thread_self(), 4);
819     // Set up for full mutex unlock/lock test
820     cyg_mutex_init(&test_mutexes[0]);
821     cyg_semaphore_init(&synchro, 0);
822     cyg_thread_create(3,              // Priority - just a number
823                       mutex_test,           // entry
824                       0,               // index
825                       thread_name("thread", 0),     // Name
826                       &stacks[0][0],   // Stack
827                       STACK_SIZE,      // Size
828                       &mutex_test_thread_handle,   // Handle
829                       &mutex_test_thread    // Thread data structure
830         );
831     cyg_thread_resume(mutex_test_thread_handle);
832     // Need to raise priority so that this thread will block on the "lock"
833     cyg_thread_set_priority(cyg_thread_self(), 2);
834     for (i = 0;  i < nmutexes;  i++) {
835         cyg_semaphore_post(&synchro);
836         cyg_mutex_lock(&test_mutexes[0]);
837         HAL_CLOCK_READ(&mutex_ft[i].end);
838         cyg_mutex_unlock(&test_mutexes[0]);
839         cyg_semaphore_wait(&synchro);
840     }
841     cyg_thread_delete(mutex_test_thread_handle);
842     show_times(mutex_ft, nmutexes, "Unlock/Lock mutex");
843 }
844
845 void
846 run_mbox_tests(void)
847 {
848     int i, cnt;
849     void *item;
850     // Mailbox primitives
851     wait_for_tick(); // Wait until the next clock tick to minimize aberations
852     for (i = 0;  i < nmboxes;  i++) {
853         HAL_CLOCK_READ(&mbox_ft[i].start);
854         cyg_mbox_create(&test_mbox_handles[i], &test_mboxes[i]);
855         HAL_CLOCK_READ(&mbox_ft[i].end);
856     }
857     show_times(mbox_ft, nmboxes, "Create mbox");
858
859     wait_for_tick(); // Wait until the next clock tick to minimize aberations
860     for (i = 0;  i < nmboxes;  i++) {
861         HAL_CLOCK_READ(&mbox_ft[i].start);
862         cnt = cyg_mbox_peek(test_mbox_handles[i]);
863         HAL_CLOCK_READ(&mbox_ft[i].end);
864     }
865     show_times(mbox_ft, nmboxes, "Peek [empty] mbox");
866
867 #ifdef CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT
868     wait_for_tick(); // Wait until the next clock tick to minimize aberations
869     for (i = 0;  i < nmboxes;  i++) {
870         HAL_CLOCK_READ(&mbox_ft[i].start);
871         cyg_mbox_put(test_mbox_handles[i], (void *)i);
872         HAL_CLOCK_READ(&mbox_ft[i].end);
873     }
874     show_times(mbox_ft, nmboxes, "Put [first] mbox");
875
876     wait_for_tick(); // Wait until the next clock tick to minimize aberations
877     for (i = 0;  i < nmboxes;  i++) {
878         HAL_CLOCK_READ(&mbox_ft[i].start);
879         cnt = cyg_mbox_peek(test_mbox_handles[i]);
880         HAL_CLOCK_READ(&mbox_ft[i].end);
881     }
882     show_times(mbox_ft, nmboxes, "Peek [1 msg] mbox");
883
884     wait_for_tick(); // Wait until the next clock tick to minimize aberations
885     for (i = 0;  i < nmboxes;  i++) {
886         HAL_CLOCK_READ(&mbox_ft[i].start);
887         cyg_mbox_put(test_mbox_handles[i], (void *)i);
888         HAL_CLOCK_READ(&mbox_ft[i].end);
889     }
890     show_times(mbox_ft, nmboxes, "Put [second] mbox");
891
892     wait_for_tick(); // Wait until the next clock tick to minimize aberations
893     for (i = 0;  i < nmboxes;  i++) {
894         HAL_CLOCK_READ(&mbox_ft[i].start);
895         cnt = cyg_mbox_peek(test_mbox_handles[i]);
896         HAL_CLOCK_READ(&mbox_ft[i].end);
897     }
898     show_times(mbox_ft, nmboxes, "Peek [2 msgs] mbox");
899
900     wait_for_tick(); // Wait until the next clock tick to minimize aberations
901     for (i = 0;  i < nmboxes;  i++) {
902         HAL_CLOCK_READ(&mbox_ft[i].start);
903         item = cyg_mbox_get(test_mbox_handles[i]);
904         HAL_CLOCK_READ(&mbox_ft[i].end);
905     }
906     show_times(mbox_ft, nmboxes, "Get [first] mbox");
907
908     wait_for_tick(); // Wait until the next clock tick to minimize aberations
909     for (i = 0;  i < nmboxes;  i++) {
910         HAL_CLOCK_READ(&mbox_ft[i].start);
911         item = cyg_mbox_get(test_mbox_handles[i]);
912         HAL_CLOCK_READ(&mbox_ft[i].end);
913     }
914     show_times(mbox_ft, nmboxes, "Get [second] mbox");
915 #endif // ifdef CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT
916
917     wait_for_tick(); // Wait until the next clock tick to minimize aberations
918     for (i = 0;  i < nmboxes;  i++) {
919         HAL_CLOCK_READ(&mbox_ft[i].start);
920         cyg_mbox_tryput(test_mbox_handles[i], (void *)i);
921         HAL_CLOCK_READ(&mbox_ft[i].end);
922     }
923     show_times(mbox_ft, nmboxes, "Tryput [first] mbox");
924
925     wait_for_tick(); // Wait until the next clock tick to minimize aberations
926     for (i = 0;  i < nmboxes;  i++) {
927         HAL_CLOCK_READ(&mbox_ft[i].start);
928         item = cyg_mbox_peek_item(test_mbox_handles[i]);
929         HAL_CLOCK_READ(&mbox_ft[i].end);
930     }
931     show_times(mbox_ft, nmboxes, "Peek item [non-empty] mbox");
932
933     wait_for_tick(); // Wait until the next clock tick to minimize aberations
934     for (i = 0;  i < nmboxes;  i++) {
935         HAL_CLOCK_READ(&mbox_ft[i].start);
936         item = cyg_mbox_tryget(test_mbox_handles[i]);
937         HAL_CLOCK_READ(&mbox_ft[i].end);
938     }
939     show_times(mbox_ft, nmboxes, "Tryget [non-empty] mbox");
940
941     wait_for_tick(); // Wait until the next clock tick to minimize aberations
942     for (i = 0;  i < nmboxes;  i++) {
943         HAL_CLOCK_READ(&mbox_ft[i].start);
944         item = cyg_mbox_peek_item(test_mbox_handles[i]);
945         HAL_CLOCK_READ(&mbox_ft[i].end);
946     }
947     show_times(mbox_ft, nmboxes, "Peek item [empty] mbox");
948
949     wait_for_tick(); // Wait until the next clock tick to minimize aberations
950     for (i = 0;  i < nmboxes;  i++) {
951         HAL_CLOCK_READ(&mbox_ft[i].start);
952         item = cyg_mbox_tryget(test_mbox_handles[i]);
953         HAL_CLOCK_READ(&mbox_ft[i].end);
954     }
955     show_times(mbox_ft, nmboxes, "Tryget [empty] mbox");
956
957     wait_for_tick(); // Wait until the next clock tick to minimize aberations
958     for (i = 0;  i < nmboxes;  i++) {
959         HAL_CLOCK_READ(&mbox_ft[i].start);
960         cyg_mbox_waiting_to_get(test_mbox_handles[i]);
961         HAL_CLOCK_READ(&mbox_ft[i].end);
962     }
963     show_times(mbox_ft, nmboxes, "Waiting to get mbox");
964
965     wait_for_tick(); // Wait until the next clock tick to minimize aberations
966     for (i = 0;  i < nmboxes;  i++) {
967         HAL_CLOCK_READ(&mbox_ft[i].start);
968         cyg_mbox_waiting_to_put(test_mbox_handles[i]);
969         HAL_CLOCK_READ(&mbox_ft[i].end);
970     }
971     show_times(mbox_ft, nmboxes, "Waiting to put mbox");
972
973     wait_for_tick(); // Wait until the next clock tick to minimize aberations
974     for (i = 0;  i < nmboxes;  i++) {
975         HAL_CLOCK_READ(&mbox_ft[i].start);
976         cyg_mbox_delete(test_mbox_handles[i]);
977         HAL_CLOCK_READ(&mbox_ft[i].end);
978     }
979     show_times(mbox_ft, nmboxes, "Delete mbox");
980
981     run_mbox_circuit_test();
982     end_of_test_group();
983 }
984
985 void
986 run_mbox_circuit_test(void)
987 {
988 #ifdef CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT
989     int i;
990     // Set my priority lower than any I plan to create
991     cyg_thread_set_priority(cyg_thread_self(), 3);
992     // Set up for full mbox put/get test
993     cyg_mbox_create(&test_mbox_handles[0], &test_mboxes[0]);
994     cyg_semaphore_init(&synchro, 0);
995     cyg_thread_create(2,              // Priority - just a number
996                       mbox_test,           // entry
997                       0,               // index
998                       thread_name("thread", 0),     // Name
999                       &stacks[0][0],   // Stack
1000                       STACK_SIZE,      // Size
1001                       &mbox_test_thread_handle,   // Handle
1002                       &mbox_test_thread    // Thread data structure
1003         );
1004     cyg_thread_resume(mbox_test_thread_handle);
1005     for (i = 0;  i < nmboxes;  i++) {
1006         wait_for_tick(); // Wait until the next clock tick to minimize aberations
1007         HAL_CLOCK_READ(&mbox_ft[i].start);
1008         cyg_mbox_put(test_mbox_handles[0], (void *)i);
1009         cyg_semaphore_wait(&synchro);
1010     }
1011     cyg_thread_delete(mbox_test_thread_handle);
1012     show_times(mbox_ft, nmboxes, "Put/Get mbox");
1013 #endif
1014 }
1015
1016 void
1017 run_semaphore_tests(void)
1018 {
1019     int i;
1020     cyg_count32 sem_val;
1021     // Semaphore primitives
1022     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1023     for (i = 0;  i < nsemaphores;  i++) {
1024         HAL_CLOCK_READ(&semaphore_ft[i].start);
1025         cyg_semaphore_init(&test_semaphores[i], 0);
1026         HAL_CLOCK_READ(&semaphore_ft[i].end);
1027     }
1028     show_times(semaphore_ft, nsemaphores, "Init semaphore");
1029
1030     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1031     for (i = 0;  i < nsemaphores;  i++) {
1032         HAL_CLOCK_READ(&semaphore_ft[i].start);
1033         cyg_semaphore_post(&test_semaphores[i]);
1034         HAL_CLOCK_READ(&semaphore_ft[i].end);
1035     }
1036     show_times(semaphore_ft, nsemaphores, "Post [0] semaphore");
1037
1038     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1039     for (i = 0;  i < nsemaphores;  i++) {
1040         HAL_CLOCK_READ(&semaphore_ft[i].start);
1041         cyg_semaphore_wait(&test_semaphores[i]);
1042         HAL_CLOCK_READ(&semaphore_ft[i].end);
1043     }
1044     show_times(semaphore_ft, nsemaphores, "Wait [1] semaphore");
1045
1046     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1047     for (i = 0;  i < nsemaphores;  i++) {
1048         HAL_CLOCK_READ(&semaphore_ft[i].start);
1049         cyg_semaphore_trywait(&test_semaphores[i]);
1050         HAL_CLOCK_READ(&semaphore_ft[i].end);
1051     }
1052     show_times(semaphore_ft, nsemaphores, "Trywait [0] semaphore");
1053
1054     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1055     for (i = 0;  i < nsemaphores;  i++) {
1056         cyg_semaphore_post(&test_semaphores[i]);
1057         HAL_CLOCK_READ(&semaphore_ft[i].start);
1058         cyg_semaphore_trywait(&test_semaphores[i]);
1059         HAL_CLOCK_READ(&semaphore_ft[i].end);
1060     }
1061     show_times(semaphore_ft, nsemaphores, "Trywait [1] semaphore");
1062
1063     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1064     for (i = 0;  i < nsemaphores;  i++) {
1065         HAL_CLOCK_READ(&semaphore_ft[i].start);
1066         cyg_semaphore_peek(&test_semaphores[i], &sem_val);
1067         HAL_CLOCK_READ(&semaphore_ft[i].end);
1068     }
1069     show_times(semaphore_ft, nsemaphores, "Peek semaphore");
1070
1071     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1072     for (i = 0;  i < nsemaphores;  i++) {
1073         HAL_CLOCK_READ(&semaphore_ft[i].start);
1074         cyg_semaphore_destroy(&test_semaphores[i]);
1075         HAL_CLOCK_READ(&semaphore_ft[i].end);
1076     }
1077     show_times(semaphore_ft, nsemaphores, "Destroy semaphore");
1078
1079     run_semaphore_circuit_test();
1080     end_of_test_group();
1081 }
1082
1083 void
1084 run_semaphore_circuit_test(void)
1085 {
1086     int i;
1087     // Set my priority lower than any I plan to create
1088     cyg_thread_set_priority(cyg_thread_self(), 3);
1089     // Set up for full semaphore post/wait test
1090     cyg_semaphore_init(&test_semaphores[0], 0);
1091     cyg_semaphore_init(&synchro, 0);
1092     cyg_thread_create(2,              // Priority - just a number
1093                       semaphore_test,           // entry
1094                       0,               // index
1095                       thread_name("thread", 0),     // Name
1096                       &stacks[0][0],   // Stack
1097                       STACK_SIZE,      // Size
1098                       &semaphore_test_thread_handle,   // Handle
1099                       &semaphore_test_thread    // Thread data structure
1100         );
1101     cyg_thread_resume(semaphore_test_thread_handle);
1102     for (i = 0;  i < nsemaphores;  i++) {
1103         wait_for_tick(); // Wait until the next clock tick to minimize aberations
1104         HAL_CLOCK_READ(&semaphore_ft[i].start);
1105         cyg_semaphore_post(&test_semaphores[0]);
1106         cyg_semaphore_wait(&synchro);
1107     }
1108     cyg_thread_delete(semaphore_test_thread_handle);
1109     show_times(semaphore_ft, nsemaphores, "Post/Wait semaphore");
1110 }
1111
1112 void
1113 run_counter_tests(void)
1114 {
1115     int i;
1116     cyg_tick_count_t val=0;
1117
1118     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1119     for (i = 0;  i < ncounters;  i++) {
1120         HAL_CLOCK_READ(&counter_ft[i].start);
1121         cyg_counter_create(&counters[i], &test_counters[i]);
1122         HAL_CLOCK_READ(&counter_ft[i].end);
1123     }
1124     show_times(counter_ft, ncounters, "Create counter");
1125
1126     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1127     for (i = 0;  i < ncounters;  i++) {
1128         HAL_CLOCK_READ(&counter_ft[i].start);
1129         val = cyg_counter_current_value(counters[i]);
1130         HAL_CLOCK_READ(&counter_ft[i].end);
1131     }
1132     show_times(counter_ft, ncounters, "Get counter value");
1133
1134     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1135     for (i = 0;  i < ncounters;  i++) {
1136         HAL_CLOCK_READ(&counter_ft[i].start);
1137         cyg_counter_set_value(counters[i], val);
1138         HAL_CLOCK_READ(&counter_ft[i].end);
1139     }
1140     show_times(counter_ft, ncounters, "Set counter value");
1141
1142     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1143     for (i = 0;  i < ncounters;  i++) {
1144         HAL_CLOCK_READ(&counter_ft[i].start);
1145         cyg_counter_tick(counters[i]);
1146         HAL_CLOCK_READ(&counter_ft[i].end);
1147     }
1148     show_times(counter_ft, ncounters, "Tick counter");
1149
1150     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1151     for (i = 0;  i < ncounters;  i++) {
1152         HAL_CLOCK_READ(&counter_ft[i].start);
1153         cyg_counter_delete(counters[i]);
1154         HAL_CLOCK_READ(&counter_ft[i].end);
1155     }
1156     show_times(counter_ft, ncounters, "Delete counter");
1157     end_of_test_group();
1158 }
1159
1160 void
1161 run_flag_tests(void)
1162 {
1163     int i;
1164     cyg_flag_value_t val;
1165
1166     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1167     for (i = 0;  i < nflags;  i++) {
1168         HAL_CLOCK_READ(&flag_ft[i].start);
1169         cyg_flag_init(&test_flags[i]);
1170         HAL_CLOCK_READ(&flag_ft[i].end);
1171     }
1172     show_times(flag_ft, nflags, "Init flag");
1173
1174     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1175     for (i = 0;  i < nflags;  i++) {
1176         HAL_CLOCK_READ(&flag_ft[i].start);
1177         cyg_flag_destroy(&test_flags[i]);
1178         HAL_CLOCK_READ(&flag_ft[i].end);
1179     }
1180     show_times(flag_ft, nflags, "Destroy flag");
1181
1182     // Recreate the flags - reused in the remaining tests
1183     for (i = 0;  i < nflags;  i++) {
1184         cyg_flag_init(&test_flags[i]);
1185     }
1186
1187     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1188     for (i = 0;  i < nflags;  i++) {
1189         HAL_CLOCK_READ(&flag_ft[i].start);
1190         cyg_flag_maskbits(&test_flags[i], 0);
1191         HAL_CLOCK_READ(&flag_ft[i].end);
1192     }
1193     show_times(flag_ft, nflags, "Mask bits in flag");
1194
1195     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1196     for (i = 0;  i < nflags;  i++) {
1197         HAL_CLOCK_READ(&flag_ft[i].start);
1198         cyg_flag_setbits(&test_flags[i], 0x11);
1199         HAL_CLOCK_READ(&flag_ft[i].end);
1200     }
1201     show_times(flag_ft, nflags, "Set bits in flag [no waiters]");
1202
1203     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1204     for (i = 0;  i < nflags;  i++) {
1205         cyg_flag_setbits(&test_flags[i], 0x11);
1206         HAL_CLOCK_READ(&flag_ft[i].start);
1207         cyg_flag_wait(&test_flags[i], 0x11, CYG_FLAG_WAITMODE_AND);
1208         HAL_CLOCK_READ(&flag_ft[i].end);
1209     }
1210     show_times(flag_ft, nflags, "Wait for flag [AND]");
1211
1212     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1213     for (i = 0;  i < nflags;  i++) {
1214         cyg_flag_setbits(&test_flags[i], 0x11);
1215         HAL_CLOCK_READ(&flag_ft[i].start);
1216         cyg_flag_wait(&test_flags[i], 0x11, CYG_FLAG_WAITMODE_OR);
1217         HAL_CLOCK_READ(&flag_ft[i].end);
1218     }
1219     show_times(flag_ft, nflags, "Wait for flag [OR]");
1220
1221     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1222     for (i = 0;  i < nflags;  i++) {
1223         cyg_flag_setbits(&test_flags[i], 0x11);
1224         HAL_CLOCK_READ(&flag_ft[i].start);
1225         cyg_flag_wait(&test_flags[i], 0x11, CYG_FLAG_WAITMODE_AND|CYG_FLAG_WAITMODE_CLR);
1226         HAL_CLOCK_READ(&flag_ft[i].end);
1227     }
1228     show_times(flag_ft, nflags, "Wait for flag [AND/CLR]");
1229
1230     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1231     for (i = 0;  i < nflags;  i++) {
1232         cyg_flag_setbits(&test_flags[i], 0x11);
1233         HAL_CLOCK_READ(&flag_ft[i].start);
1234         cyg_flag_wait(&test_flags[i], 0x11, CYG_FLAG_WAITMODE_OR|CYG_FLAG_WAITMODE_CLR);
1235         HAL_CLOCK_READ(&flag_ft[i].end);
1236     }
1237     show_times(flag_ft, nflags, "Wait for flag [OR/CLR]");
1238
1239     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1240     for (i = 0;  i < nflags;  i++) {
1241         cyg_flag_setbits(&test_flags[i], 0x11);
1242         HAL_CLOCK_READ(&flag_ft[i].start);
1243         val = cyg_flag_peek(&test_flags[i]);
1244         HAL_CLOCK_READ(&flag_ft[i].end);
1245     }
1246     show_times(flag_ft, nflags, "Peek on flag");
1247
1248     // Destroy flags - no longer needed
1249     for (i = 0;  i < nflags;  i++) {
1250         cyg_flag_destroy(&test_flags[i]);
1251     }
1252     end_of_test_group();
1253 }
1254
1255 // Alarm callback function
1256 void
1257 alarm_cb(cyg_handle_t alarm, cyg_addrword_t val)
1258 {
1259     // empty call back
1260 }
1261
1262 // Callback used to test determinancy
1263 static volatile int alarm_cnt;
1264 void
1265 alarm_cb2(cyg_handle_t alarm, cyg_addrword_t indx)
1266 {
1267     if (alarm_cnt == nscheds) return;
1268     sched_ft[alarm_cnt].start = 0;
1269     HAL_CLOCK_READ(&sched_ft[alarm_cnt++].end);
1270     if (alarm_cnt == nscheds) {
1271         cyg_semaphore_post(&synchro);
1272     }
1273 }
1274
1275 static void
1276 alarm_cb3(cyg_handle_t alarm, cyg_addrword_t indx)
1277 {
1278     if (alarm_cnt == nscheds) {
1279         cyg_semaphore_post(&synchro);
1280     } else {
1281         sched_ft[alarm_cnt].start = 0;
1282         cyg_thread_resume((cyg_handle_t)indx);
1283     }
1284 }
1285
1286 // Null thread, used to keep scheduler busy
1287 void
1288 alarm_test(cyg_uint32 id)
1289 {
1290     while (true) {
1291         cyg_thread_yield();
1292     }
1293 }
1294
1295 // Thread that suspends itself at the first opportunity
1296 void
1297 alarm_test2(cyg_uint32 id)
1298 {
1299     cyg_handle_t me = cyg_thread_self();
1300     while (true) {
1301         HAL_CLOCK_READ(&sched_ft[alarm_cnt++].end);
1302         cyg_thread_suspend(me);
1303     }
1304 }
1305
1306 void
1307 run_alarm_tests(void)
1308 {
1309     int i;
1310     cyg_tick_count_t init_val, step_val;
1311     cyg_handle_t rtc_handle;
1312
1313     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1314     for (i = 0;  i < ncounters;  i++) {
1315         cyg_counter_create(&counters[i], &test_counters[i]);
1316     }
1317     for (i = 0;  i < nalarms;  i++) {
1318         HAL_CLOCK_READ(&alarm_ft[i].start);
1319         cyg_alarm_create(counters[0], alarm_cb, 0, &alarms[i], &test_alarms[i]);
1320         HAL_CLOCK_READ(&alarm_ft[i].end);
1321     }
1322     show_times(alarm_ft, nalarms, "Create alarm");
1323
1324     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1325     init_val = 0;  step_val = 0;
1326     for (i = 0;  i < nalarms;  i++) {
1327         HAL_CLOCK_READ(&alarm_ft[i].start);
1328         cyg_alarm_initialize(alarms[i], init_val, step_val);
1329         HAL_CLOCK_READ(&alarm_ft[i].end);
1330     }
1331     show_times(alarm_ft, nalarms, "Initialize alarm");
1332
1333     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1334     init_val = 0;  step_val = 0;
1335     for (i = 0;  i < nalarms;  i++) {
1336         HAL_CLOCK_READ(&alarm_ft[i].start);
1337         cyg_alarm_disable(alarms[i]);
1338         HAL_CLOCK_READ(&alarm_ft[i].end);
1339     }
1340     show_times(alarm_ft, nalarms, "Disable alarm");
1341
1342     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1343     init_val = 0;  step_val = 0;
1344     for (i = 0;  i < nalarms;  i++) {
1345         HAL_CLOCK_READ(&alarm_ft[i].start);
1346         cyg_alarm_enable(alarms[i]);
1347         HAL_CLOCK_READ(&alarm_ft[i].end);
1348     }
1349     show_times(alarm_ft, nalarms, "Enable alarm");
1350
1351     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1352     for (i = 0;  i < nalarms;  i++) {
1353         HAL_CLOCK_READ(&alarm_ft[i].start);
1354         cyg_alarm_delete(alarms[i]);
1355         HAL_CLOCK_READ(&alarm_ft[i].end);
1356     }
1357     show_times(alarm_ft, nalarms, "Delete alarm");
1358
1359     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1360     cyg_counter_create(&counters[0], &test_counters[0]);
1361     cyg_alarm_create(counters[0], alarm_cb, 0, &alarms[0], &test_alarms[0]);
1362     init_val = 9999;  step_val = 9999;
1363     cyg_alarm_initialize(alarms[0], init_val, step_val);
1364     cyg_alarm_enable(alarms[0]);
1365     for (i = 0;  i < ncounters;  i++) {
1366         HAL_CLOCK_READ(&counter_ft[i].start);
1367         cyg_counter_tick(counters[0]);
1368         HAL_CLOCK_READ(&counter_ft[i].end);
1369     }
1370     show_times(counter_ft, ncounters, "Tick counter [1 alarm]");
1371
1372     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1373     cyg_counter_create(&counters[0], &test_counters[0]);
1374     for (i = 0;  i < nalarms;  i++) {
1375         cyg_alarm_create(counters[0], alarm_cb, 0, &alarms[i], &test_alarms[i]);
1376         init_val = 9999;  step_val = 9999;
1377         cyg_alarm_initialize(alarms[i], init_val, step_val);
1378         cyg_alarm_enable(alarms[i]);
1379     }
1380     for (i = 0;  i < ncounters;  i++) {
1381         HAL_CLOCK_READ(&counter_ft[i].start);
1382         cyg_counter_tick(counters[0]);
1383         HAL_CLOCK_READ(&counter_ft[i].end);
1384     }
1385     show_times(counter_ft, ncounters, "Tick counter [many alarms]");
1386
1387     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1388     cyg_counter_create(&counters[0], &test_counters[0]);
1389     cyg_alarm_create(counters[0], alarm_cb, 0, &alarms[0], &test_alarms[0]);
1390     init_val = 1;  step_val = 1;
1391     cyg_alarm_initialize(alarms[0], init_val, step_val);
1392     cyg_alarm_enable(alarms[0]);
1393     for (i = 0;  i < ncounters;  i++) {
1394         HAL_CLOCK_READ(&counter_ft[i].start);
1395         cyg_counter_tick(counters[0]);
1396         HAL_CLOCK_READ(&counter_ft[i].end);
1397     }
1398     show_times(counter_ft, ncounters, "Tick & fire counter [1 alarm]");
1399
1400     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1401     cyg_counter_create(&counters[0], &test_counters[0]);
1402     for (i = 0;  i < nalarms;  i++) {
1403         cyg_alarm_create(counters[0], alarm_cb, i, &alarms[i], &test_alarms[i]);
1404         init_val = 1;  step_val = 1;
1405         cyg_alarm_initialize(alarms[i], init_val, step_val);
1406         cyg_alarm_enable(alarms[i]);
1407     }
1408     for (i = 0;  i < nalarms;  i++) {
1409         HAL_CLOCK_READ(&alarm_ft[i].start);
1410         cyg_counter_tick(counters[0]);
1411         HAL_CLOCK_READ(&alarm_ft[i].end);
1412     }
1413     for (i = 0;  i < nalarms;  i++) {
1414         cyg_alarm_delete(alarms[i]);
1415     }
1416     show_times(alarm_ft, nalarms, "Tick & fire counters [>1 together]");
1417
1418     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1419     cyg_counter_create(&counters[0], &test_counters[0]);
1420     for (i = 0;  i < nalarms;  i++) {
1421         cyg_alarm_create(counters[0], alarm_cb, i, &alarms[i], &test_alarms[i]);
1422         init_val = i+1;  step_val = nalarms+1;
1423         cyg_alarm_initialize(alarms[i], init_val, step_val);
1424         cyg_alarm_enable(alarms[i]);
1425     }
1426     for (i = 0;  i < nalarms;  i++) {
1427         HAL_CLOCK_READ(&alarm_ft[i].start);
1428         cyg_counter_tick(counters[0]);
1429         HAL_CLOCK_READ(&alarm_ft[i].end);
1430     }
1431     for (i = 0;  i < nalarms;  i++) {
1432         cyg_alarm_delete(alarms[i]);
1433     }
1434     show_times(alarm_ft, nalarms, "Tick & fire counters [>1 separately]");
1435
1436     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1437     cyg_clock_to_counter(cyg_real_time_clock(), &rtc_handle);
1438     cyg_alarm_create(rtc_handle, alarm_cb2, 0, &alarms[0], &test_alarms[0]);
1439     init_val = 5;  step_val = 5;  alarm_cnt = 0;
1440     cyg_alarm_initialize(alarms[0], init_val, step_val);
1441     cyg_semaphore_init(&synchro, 0);
1442     cyg_alarm_enable(alarms[0]);
1443     cyg_semaphore_wait(&synchro);
1444     cyg_alarm_disable(alarms[0]);
1445     cyg_alarm_delete(alarms[0]);
1446     show_times(sched_ft, nscheds, "Alarm latency [0 threads]");
1447
1448     // Set my priority higher than any I plan to create
1449     cyg_thread_set_priority(cyg_thread_self(), 2);
1450     for (i = 0;  i < 2;  i++) {
1451         cyg_thread_create(10,              // Priority - just a number
1452                           alarm_test,      // entry
1453                           i,               // index
1454                           thread_name("thread", i),     // Name
1455                           &stacks[i][0],   // Stack
1456                           STACK_SIZE,      // Size
1457                           &threads[i],     // Handle
1458                           &test_threads[i] // Thread data structure
1459             );
1460         cyg_thread_resume(threads[i]);
1461     }
1462     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1463     cyg_clock_to_counter(cyg_real_time_clock(), &rtc_handle);
1464     cyg_alarm_create(rtc_handle, alarm_cb2, 0, &alarms[0], &test_alarms[0]);
1465     init_val = 5;  step_val = 5;  alarm_cnt = 0;
1466     cyg_alarm_initialize(alarms[0], init_val, step_val);
1467     cyg_semaphore_init(&synchro, 0);
1468     cyg_alarm_enable(alarms[0]);
1469     cyg_semaphore_wait(&synchro);
1470     cyg_alarm_disable(alarms[0]);
1471     cyg_alarm_delete(alarms[0]);
1472     show_times(sched_ft, nscheds, "Alarm latency [2 threads]");
1473     for (i = 0;  i < 2;  i++) {
1474         cyg_thread_suspend(threads[i]);
1475         cyg_thread_delete(threads[i]);
1476     }
1477
1478     // Set my priority higher than any I plan to create
1479     cyg_thread_set_priority(cyg_thread_self(), 2);
1480     for (i = 0;  i < ntest_threads;  i++) {
1481         cyg_thread_create(10,              // Priority - just a number
1482                           alarm_test,      // entry
1483                           i,               // index
1484                           thread_name("thread", i),     // Name
1485                           &stacks[i][0],   // Stack
1486                           STACK_SIZE,      // Size
1487                           &threads[i],     // Handle
1488                           &test_threads[i] // Thread data structure
1489             );
1490         cyg_thread_resume(threads[i]);
1491     }
1492     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1493     cyg_clock_to_counter(cyg_real_time_clock(), &rtc_handle);
1494     cyg_alarm_create(rtc_handle, alarm_cb2, 0, &alarms[0], &test_alarms[0]);
1495     init_val = 5;  step_val = 5;  alarm_cnt = 0;
1496     cyg_alarm_initialize(alarms[0], init_val, step_val);
1497     cyg_semaphore_init(&synchro, 0);
1498     cyg_alarm_enable(alarms[0]);
1499     cyg_semaphore_wait(&synchro);
1500     cyg_alarm_disable(alarms[0]);
1501     cyg_alarm_delete(alarms[0]);
1502     show_times(sched_ft, nscheds, "Alarm latency [many threads]");
1503     for (i = 0;  i < ntest_threads;  i++) {
1504         cyg_thread_suspend(threads[i]);
1505         cyg_thread_delete(threads[i]);
1506     }
1507
1508     // Set my priority higher than any I plan to create
1509     cyg_thread_set_priority(cyg_thread_self(), 2);
1510     cyg_thread_create(10,              // Priority - just a number
1511                       alarm_test2,     // entry
1512                       i,               // index
1513                       thread_name("thread", 0),     // Name
1514                       &stacks[0][0],   // Stack
1515                       STACK_SIZE,      // Size
1516                       &threads[0],     // Handle
1517                       &test_threads[0] // Thread data structure
1518         );
1519     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1520     cyg_clock_to_counter(cyg_real_time_clock(), &rtc_handle);
1521     cyg_alarm_create(rtc_handle, alarm_cb3, threads[0], &alarms[0],
1522                      &test_alarms[0]);
1523     init_val = 5;  step_val = 5;  alarm_cnt = 0;
1524     cyg_alarm_initialize(alarms[0], init_val, step_val);
1525     cyg_semaphore_init(&synchro, 0);
1526     cyg_alarm_enable(alarms[0]);
1527     cyg_semaphore_wait(&synchro);
1528     cyg_alarm_disable(alarms[0]);
1529     cyg_alarm_delete(alarms[0]);
1530     show_times(sched_ft, nscheds, "Alarm -> thread resume latency");
1531     cyg_thread_suspend(threads[0]);
1532     cyg_thread_delete(threads[0]);
1533     
1534     end_of_test_group();
1535 }
1536
1537 void
1538 run_sched_tests(void)
1539 {
1540     int i;
1541
1542     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1543     for (i = 0;  i < nscheds;  i++) {
1544         HAL_CLOCK_READ(&sched_ft[i].start);
1545         cyg_scheduler_lock();
1546         HAL_CLOCK_READ(&sched_ft[i].end);
1547         cyg_scheduler_unlock();
1548     }
1549     show_times(sched_ft, nscheds, "Scheduler lock");
1550
1551     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1552     for (i = 0;  i < nscheds;  i++) {
1553         cyg_scheduler_lock();
1554         HAL_CLOCK_READ(&sched_ft[i].start);
1555         cyg_scheduler_unlock();
1556         HAL_CLOCK_READ(&sched_ft[i].end);
1557     }
1558     show_times(sched_ft, nscheds, "Scheduler unlock [0 threads]");
1559
1560     // Set my priority higher than any I plan to create
1561     cyg_thread_set_priority(cyg_thread_self(), 2);
1562     for (i = 0;  i < 1;  i++) {
1563         cyg_thread_create(10,              // Priority - just a number
1564                           test0,           // entry
1565                           i,               // index
1566                           thread_name("thread", i),     // Name
1567                           &stacks[i][0],   // Stack
1568                           STACK_SIZE,      // Size
1569                           &threads[i],     // Handle
1570                           &test_threads[i] // Thread data structure
1571             );
1572     }
1573     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1574     for (i = 0;  i < nscheds;  i++) {
1575         cyg_scheduler_lock();
1576         HAL_CLOCK_READ(&sched_ft[i].start);
1577         cyg_scheduler_unlock();
1578         HAL_CLOCK_READ(&sched_ft[i].end);
1579     }
1580     show_times(sched_ft, nscheds, "Scheduler unlock [1 suspended]");
1581     for (i = 0;  i < 1;  i++) {
1582         cyg_thread_delete(threads[i]);
1583     }
1584
1585     // Set my priority higher than any I plan to create
1586     cyg_thread_set_priority(cyg_thread_self(), 2);
1587     for (i = 0;  i < ntest_threads;  i++) {
1588         cyg_thread_create(10,              // Priority - just a number
1589                           test0,           // entry
1590                           i,               // index
1591                           thread_name("thread", i),     // Name
1592                           &stacks[i][0],   // Stack
1593                           STACK_SIZE,      // Size
1594                           &threads[i],     // Handle
1595                           &test_threads[i] // Thread data structure
1596             );
1597     }
1598     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1599     for (i = 0;  i < nscheds;  i++) {
1600         cyg_scheduler_lock();
1601         HAL_CLOCK_READ(&sched_ft[i].start);
1602         cyg_scheduler_unlock();
1603         HAL_CLOCK_READ(&sched_ft[i].end);
1604     }
1605     show_times(sched_ft, nscheds, "Scheduler unlock [many suspended]");
1606     for (i = 0;  i < ntest_threads;  i++) {
1607         cyg_thread_delete(threads[i]);
1608     }
1609
1610     // Set my priority higher than any I plan to create
1611     cyg_thread_set_priority(cyg_thread_self(), 2);
1612     for (i = 0;  i < ntest_threads;  i++) {
1613         cyg_thread_create(10,              // Priority - just a number
1614                           test0,           // entry
1615                           i,               // index
1616                           thread_name("thread", i),     // Name
1617                           &stacks[i][0],   // Stack
1618                           STACK_SIZE,      // Size
1619                           &threads[i],     // Handle
1620                           &test_threads[i] // Thread data structure
1621             );
1622         cyg_thread_resume(threads[i]);
1623     }
1624     wait_for_tick(); // Wait until the next clock tick to minimize aberations
1625     for (i = 0;  i < nscheds;  i++) {
1626         cyg_scheduler_lock();
1627         HAL_CLOCK_READ(&sched_ft[i].start);
1628         cyg_scheduler_unlock();
1629         HAL_CLOCK_READ(&sched_ft[i].end);
1630     }
1631     show_times(sched_ft, nscheds, "Scheduler unlock [many low prio]");
1632     for (i = 0;  i < ntest_threads;  i++) {
1633         cyg_thread_delete(threads[i]);
1634     }
1635     end_of_test_group();
1636 }
1637
1638 static void 
1639 _run_all_tests(CYG_ADDRESS id)
1640 {
1641     int i, j;
1642     cyg_uint32 tv[nsamples], tv0, tv1;
1643     cyg_uint32 min_stack, max_stack, total_stack, actual_stack;
1644     cyg_tick_count_t ticks, tick0, tick1;
1645 #ifdef CYG_SCHEDULER_LOCK_TIMINGS
1646     cyg_uint32 lock_ave, lock_max;
1647 #endif
1648 #if defined(CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY) && defined(HAL_CLOCK_LATENCY)
1649     cyg_int32 clock_ave;
1650 #endif
1651
1652     disable_clock_latency_measurement();
1653
1654 #ifndef CYGPKG_KERNEL_SMP_SUPPORT
1655     cyg_test_dump_thread_stack_stats( "Startup, main stack", thread[0] );
1656     cyg_test_dump_interrupt_stack_stats( "Startup" );
1657     cyg_test_dump_idlethread_stack_stats( "Startup" );
1658     cyg_test_clear_interrupt_stack();
1659 #endif
1660     
1661     diag_printf("\neCos Kernel Timings\n");
1662     diag_printf("Notes: all times are in microseconds (.000001) unless otherwise stated\n");
1663 #ifdef STATS_WITHOUT_FIRST_SAMPLE
1664     diag_printf("       second line of results have first sample removed\n");
1665 #endif
1666
1667     cyg_thread_delay(2);  // Make sure the clock is actually running
1668
1669     ns_per_system_clock = 1000000/rtc_resolution[1];
1670
1671     wait_for_tick();
1672     for (i = 0;  i < nsamples;  i++) {
1673         HAL_CLOCK_READ(&tv[i]);
1674     }
1675     tv0 = 0;
1676     for (i = 1;  i < nsamples;  i++) {
1677         tv0 += tv[i] - tv[i-1];
1678     }
1679     end_of_test_group();
1680     
1681     overhead = tv0 / (nsamples-1);
1682     diag_printf("Reading the hardware clock takes %d 'ticks' overhead\n", overhead);
1683     diag_printf("... this value will be factored out of all other measurements\n");
1684
1685     // Try and measure how long the clock interrupt handling takes
1686     for (i = 0;  i < nsamples;  i++) {
1687         tick0 = cyg_current_time();
1688         while (true) {
1689             tick1 = cyg_current_time();
1690             if (tick0 != tick1) break;
1691         }
1692         HAL_CLOCK_READ(&tv[i]);
1693     }
1694     tv1 = 0;
1695     for (i = 0;  i < nsamples;  i++) {
1696         tv1 += tv[i] * 1000;
1697     }
1698     tv1 = tv1 / nsamples;
1699     tv1 -= overhead;  // Adjust out the cost of getting the timer value
1700     diag_printf("Clock interrupt took");
1701     show_ticks_in_us(tv1);
1702     diag_printf(" microseconds (%d raw clock ticks)\n", tv1/1000);
1703     enable_clock_latency_measurement();
1704
1705     ticks = cyg_current_time();
1706
1707     show_test_parameters();
1708     show_times_hdr();
1709
1710     reset_clock_latency_measurement();
1711
1712     run_thread_tests();
1713     run_sched_tests();
1714     run_mutex_tests();
1715     run_mbox_tests();
1716     run_semaphore_tests();
1717     run_counter_tests();
1718     run_flag_tests();
1719     run_alarm_tests();
1720
1721 #ifdef CYG_SCHEDULER_LOCK_TIMINGS
1722     Cyg_Scheduler::get_lock_times(&lock_ave, &lock_max);
1723     diag_printf("\nMax lock:");
1724     show_ticks_in_us(lock_max);
1725     diag_printf(", Ave lock:");
1726     show_ticks_in_us(lock_ave);
1727     diag_printf("\n");
1728 #endif
1729
1730 #if defined(CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY) && defined(HAL_CLOCK_LATENCY)
1731     // Display latency figures in same format as all other numbers
1732     disable_clock_latency_measurement();
1733     clock_ave = (total_clock_latency*1000) / total_clock_interrupts;
1734     show_ticks_in_us(clock_ave);
1735     show_ticks_in_us(min_clock_latency*1000);
1736     show_ticks_in_us(max_clock_latency*1000);
1737     show_ticks_in_us(0);
1738     diag_printf("            Clock/interrupt latency\n\n");
1739     enable_clock_latency_measurement();    
1740 #endif
1741
1742 #if defined(CYGVAR_KERNEL_COUNTERS_CLOCK_DSR_LATENCY) && defined(HAL_CLOCK_LATENCY)
1743     disable_clock_latency_measurement();    
1744     clock_ave = (total_clock_dsr_latency*1000) / total_clock_dsr_calls;
1745     show_ticks_in_us(clock_ave);
1746     show_ticks_in_us(min_clock_dsr_latency*1000);
1747     show_ticks_in_us(max_clock_dsr_latency*1000);
1748     show_ticks_in_us(0);
1749     diag_printf("            Clock DSR latency\n\n");
1750     enable_clock_latency_measurement();
1751 #endif
1752
1753 #ifndef CYGPKG_KERNEL_SMP_SUPPORT    
1754     disable_clock_latency_measurement();
1755     min_stack = STACK_SIZE;
1756     max_stack = 0;
1757     total_stack = 0;
1758     for (i = 0;  i < (int)NTEST_THREADS;  i++) {
1759         for (j = 0;  j < STACK_SIZE;  j++) {
1760             if (stacks[i][j]) break;
1761         }
1762         actual_stack = STACK_SIZE-j;
1763         if (actual_stack < min_stack) min_stack = actual_stack;
1764         if (actual_stack > max_stack) max_stack = actual_stack;
1765         total_stack += actual_stack;
1766     }
1767     for (j = 0;  j < STACKSIZE;  j++) {
1768         if (((char *)stack[0])[j]) break;
1769     }
1770     diag_printf("%5ld  %5d   %5d  (main stack: %5d)  Thread stack used (%d total)\n", 
1771                 (unsigned long) total_stack/NTEST_THREADS, min_stack, max_stack, 
1772                 STACKSIZE - j, STACK_SIZE);
1773
1774     cyg_test_dump_thread_stack_stats( "All done, main stack", thread[0] );
1775     cyg_test_dump_interrupt_stack_stats( "All done" );
1776     cyg_test_dump_idlethread_stack_stats( "All done" );
1777 #endif
1778     
1779     enable_clock_latency_measurement();
1780
1781     ticks = cyg_current_time();
1782     diag_printf("\nTiming complete - %d ms total\n\n", (int)((ticks*ns_per_system_clock)/1000));
1783 }
1784
1785 void 
1786 run_all_tests(CYG_ADDRESS id)
1787 {
1788 #if CYGNUM_TESTS_RUN_COUNT < 0
1789     while (1)
1790 #else       
1791     int i;
1792     for (i = 0;  i < CYGNUM_TESTS_RUN_COUNT;  i++)
1793 #endif
1794         _run_all_tests(id);
1795     CYG_TEST_PASS_FINISH("Basic timing OK");
1796 }
1797
1798 void tm_basic_main( void )
1799 {
1800     CYG_TEST_INIT();
1801
1802     if (cyg_test_is_simulator) {
1803         nsamples = NSAMPLES_SIM;
1804         ntest_threads = NTEST_THREADS_SIM;
1805         nthread_switches = NTHREAD_SWITCHES_SIM;
1806         nmutexes = NMUTEXES_SIM;
1807         nmboxes = NMBOXES_SIM;
1808         nsemaphores = NSEMAPHORES_SIM;
1809         nscheds = NSCHEDS_SIM;
1810         nflags = NFLAGS_SIM;
1811         ncounters = NCOUNTERS_SIM;
1812         nalarms = NALARMS_SIM;  
1813     } else {
1814         nsamples = NSAMPLES;
1815         ntest_threads = NTEST_THREADS;
1816         nthread_switches = NTHREAD_SWITCHES;
1817         nmutexes = NMUTEXES; 
1818         nmboxes = NMBOXES;
1819         nsemaphores = NSEMAPHORES;
1820         nscheds = NSCHEDS;
1821         nflags = NFLAGS;
1822         ncounters = NCOUNTERS;
1823         nalarms = NALARMS;
1824     }
1825
1826     // Sanity
1827 #ifdef WORKHORSE_TEST
1828     ntest_threads = max(512, ntest_threads);
1829     nmutexes = max(1024, nmutexes);
1830     nsemaphores = max(1024, nsemaphores);
1831     nmboxes = max(1024, nmboxes);
1832     ncounters = max(1024, ncounters);
1833     nalarms = max(1024, nalarms);
1834 #else
1835     ntest_threads = max(64, ntest_threads);
1836     nmutexes = max(32, nmutexes);
1837     nsemaphores = max(32, nsemaphores);
1838     nmboxes = max(32, nmboxes);
1839     ncounters = max(32, ncounters);
1840     nflags = max(32, nflags);
1841     nalarms = max(32, nalarms);
1842 #endif
1843
1844     new_thread(run_all_tests, 0);
1845     
1846     Cyg_Scheduler::scheduler.start();
1847
1848 }
1849
1850 #ifdef CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG
1851 externC void
1852 cyg_hal_invoke_constructors();
1853 #endif
1854
1855 externC void
1856 cyg_start( void )
1857 {
1858 #ifdef CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG
1859     cyg_hal_invoke_constructors();
1860 #endif
1861     tm_basic_main();
1862 }   
1863
1864 #else // CYGFUN_KERNEL_API_C
1865
1866 externC void
1867 cyg_start( void )
1868 {
1869     CYG_TEST_INIT();
1870     CYG_TEST_INFO("Timing tests require:\n"
1871                 "CYGFUN_KERNEL_API_C && \n"
1872                 "CYGSEM_KERNEL_SCHED_MLQUEUE &&\n"
1873                 "CYGVAR_KERNEL_COUNTERS_CLOCK &&\n"
1874                 "!CYGDBG_INFRA_DIAG_USE_DEVICE &&\n"
1875                 "(CYGNUM_KERNEL_SCHED_PRIORITIES > 12)\n");
1876     CYG_TEST_NA("Timing tests requirements");
1877 }
1878 #endif // CYGFUN_KERNEL_API_C, etc.
1879
1880 // EOF tm_basic.cxx