source: rtems/testsuites/tmtests/tmoverhd/testtask.c @ 458bd34

4.104.114.84.9
Last change on this file since 458bd34 was 458bd34, checked in by Joel Sherrill <joel.sherrill@…>, on Nov 5, 1999 at 4:44:02 PM

This is another pass at making sure that nothing outside the BSP
unnecessarily uses any variables defined by the BSP. On this
sweep, use of BSP_Configuration and Cpu_table was eliminated.

A significant part of this modification was the addition of
macros to access fields in the RTEMS configuration structures.

This is necessary to strengthen the division between the BSP independent
parts of RTEMS and the BSPs themselves. This started after
comments and analysis by Ralf Corsepius <corsepiu@…>.

  • Property mode set to 100644
File size: 28.5 KB
Line 
1/*
2 *
3 *  COPYRIGHT (c) 1989-1998.
4 *  On-Line Applications Research Corporation (OAR).
5 *  Copyright assigned to U.S. Government, 1994.
6 *
7 *  The license and distribution terms for this file may be
8 *  found in the file LICENSE in this distribution or at
9 *  http://www.OARcorp.com/rtems/license.html.
10 *
11 *  $Id$
12 */
13
14#define TEST_INIT
15#include "system.h"
16
17rtems_unsigned8 Memory_area[ 2048 ];
18rtems_unsigned8 Internal_port_area[ 256 ];
19rtems_unsigned8 External_port_area[ 256 ];
20
21rtems_task Task_1(
22  rtems_task_argument argument
23);
24
25rtems_task Init(
26  rtems_task_argument argument
27)
28{ rtems_id id;
29  rtems_status_code status;
30
31  Set_find_average_overhead( TRUE );
32
33  Print_Warning();
34
35  puts( "\n\n*** TIME TEST OVERHEAD ***" );
36
37  status = rtems_task_create(
38    rtems_build_name( 'T', 'A', '1', ' ' ),
39    254,
40    RTEMS_MINIMUM_STACK_SIZE,
41    RTEMS_DEFAULT_MODES,
42    RTEMS_DEFAULT_ATTRIBUTES,
43    &id
44  );
45  directive_failed( status, "rtems_task_create of TA1" );
46
47  status = rtems_task_start( id, Task_1, 0 );
48  directive_failed( status, "rtems_task_start of TA1" );
49
50  status = rtems_task_delete( RTEMS_SELF );
51  directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
52}
53
54/* comment out the following include to verify type are correct */
55#include "dumrtems.h"
56
57rtems_task Task_1(
58  rtems_task_argument argument
59)
60{
61  rtems_name                 name;
62  rtems_unsigned32           index;
63  rtems_cpu_table            cpu_table;
64  rtems_id                   id;
65  rtems_task_priority        in_priority;
66  rtems_task_priority        out_priority;
67  rtems_mode                 in_mode;
68  rtems_mode                 mask;
69  rtems_mode                 out_mode;
70  rtems_unsigned32           note;
71  rtems_time_of_day          time;
72  rtems_interval             timeout;
73  rtems_signal_set           signals;
74  void                      *address_1;
75  rtems_event_set            events;
76  long                       buffer[ 4 ];
77  rtems_unsigned32           count;
78  rtems_device_major_number  major;
79  rtems_device_minor_number  minor;
80  rtems_unsigned32           io_result;
81  rtems_unsigned32           error;
82  rtems_clock_get_options    options;
83
84  name        = rtems_build_name( 'N', 'A', 'M', 'E' );
85  in_priority = 250;
86  in_mode     = RTEMS_NO_PREEMPT;
87  mask        = RTEMS_PREEMPT_MASK;
88  note        = 8;
89  timeout     = 100;
90  signals     = RTEMS_SIGNAL_1 | RTEMS_SIGNAL_3;
91  major       = 10;
92  minor       = 0;
93  error       = 100;
94  options     = 0;
95
96/* rtems_initialize_executive */
97  Timer_initialize();
98    for ( index=1 ; index <= OPERATION_COUNT ; index++ )
99      (void) rtems_initialize_executive( rtems_configuration_get_table(), &cpu_table );
100  end_time = Read_timer();
101
102  put_time(
103    "rtems_initialize_executive",
104    end_time,
105    OPERATION_COUNT,
106    overhead,
107    0
108  );
109
110/* rtems_shutdown_executive */
111
112  Timer_initialize();
113    for ( index=1 ; index <= OPERATION_COUNT ; index++ )
114      (void) rtems_shutdown_executive( error );
115  end_time = Read_timer();
116
117  put_time(
118    "rtems_shutdown_executive",
119    end_time,
120    OPERATION_COUNT,
121    overhead,
122    0
123  );
124
125/* rtems_task_create */
126
127      Timer_initialize();
128         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
129            (void) rtems_task_create(
130               name,
131               in_priority,
132               RTEMS_MINIMUM_STACK_SIZE,
133               RTEMS_DEFAULT_MODES,
134               RTEMS_DEFAULT_ATTRIBUTES,
135               &id
136            );
137      end_time = Read_timer();
138
139      put_time(
140         "rtems_task_create",
141         end_time,
142         OPERATION_COUNT,
143         overhead,
144         0
145      );
146
147/* rtems_task_ident */
148
149      Timer_initialize();
150         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
151            (void) rtems_task_ident( name, RTEMS_SEARCH_ALL_NODES, id );
152      end_time = Read_timer();
153
154      put_time(
155         "rtems_task_ident",
156         end_time,
157         OPERATION_COUNT,
158         overhead,
159         0
160      );
161
162/* rtems_task_start */
163
164      Timer_initialize();
165         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
166            (void) rtems_task_start( id, Task_1, 0 );
167      end_time = Read_timer();
168
169      put_time(
170         "rtems_task_start",
171         end_time,
172         OPERATION_COUNT,
173         overhead,
174         0
175      );
176
177/* rtems_task_restart */
178
179      Timer_initialize();
180         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
181            (void) rtems_task_restart( id, 0 );
182      end_time = Read_timer();
183
184      put_time(
185         "rtems_task_restart",
186         end_time,
187         OPERATION_COUNT,
188         overhead,
189         0
190      );
191
192/* rtems_task_delete */
193
194      Timer_initialize();
195         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
196            (void) rtems_task_delete( id );
197      end_time = Read_timer();
198
199      put_time(
200         "rtems_task_delete",
201         end_time,
202         OPERATION_COUNT,
203         overhead,
204         0
205      );
206
207/* rtems_task_suspend */
208
209      Timer_initialize();
210         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
211            (void) rtems_task_suspend( id );
212      end_time = Read_timer();
213
214      put_time(
215         "rtems_task_suspend",
216         end_time,
217         OPERATION_COUNT,
218         overhead,
219         0
220      );
221
222/* rtems_task_resume */
223
224      Timer_initialize();
225         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
226            (void) rtems_task_resume( id );
227      end_time = Read_timer();
228
229      put_time(
230         "rtems_task_resume",
231         end_time,
232         OPERATION_COUNT,
233         overhead,
234         0
235      );
236
237/* rtems_task_set_priority */
238
239      Timer_initialize();
240         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
241            (void) rtems_task_set_priority( id, in_priority, &out_priority );
242      end_time = Read_timer();
243
244      put_time(
245         "rtems_task_set_priority",
246         end_time,
247         OPERATION_COUNT,
248         overhead,
249         0
250      );
251
252/* rtems_task_mode */
253
254      Timer_initialize();
255         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
256            (void) rtems_task_mode( in_mode, mask, &out_mode );
257      end_time = Read_timer();
258
259      put_time(
260         "rtems_task_mode",
261         end_time,
262         OPERATION_COUNT,
263         overhead,
264         0
265      );
266
267/* rtems_task_get_note */
268
269      Timer_initialize();
270         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
271            (void) rtems_task_get_note( id, 1, note );
272      end_time = Read_timer();
273
274      put_time(
275         "rtems_task_get_note",
276         end_time,
277         OPERATION_COUNT,
278         overhead,
279         0
280      );
281
282/* rtems_task_set_note */
283
284      Timer_initialize();
285         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
286            (void) rtems_task_set_note( id, 1, note );
287      end_time = Read_timer();
288
289      put_time(
290         "rtems_task_set_note",
291         end_time,
292         OPERATION_COUNT,
293         overhead,
294         0
295      );
296
297/* rtems_task_wake_when */
298
299      Timer_initialize();
300         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
301            (void) rtems_task_wake_when( time );
302      end_time = Read_timer();
303
304      put_time(
305         "rtems_task_wake_when",
306         end_time,
307         OPERATION_COUNT,
308         overhead,
309         0
310      );
311
312/* rtems_task_wake_after */
313
314      Timer_initialize();
315         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
316            (void) rtems_task_wake_after( timeout );
317      end_time = Read_timer();
318
319      put_time(
320         "rtems_task_wake_after",
321         end_time,
322         OPERATION_COUNT,
323         overhead,
324         0
325      );
326
327/* rtems_interrupt_catch */
328
329      Timer_initialize();
330         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
331            (void) rtems_interrupt_catch( Isr_handler, 5, address_1 );
332      end_time = Read_timer();
333
334      put_time(
335         "rtems_interrupt_catch",
336         end_time,
337         OPERATION_COUNT,
338         overhead,
339         0
340      );
341
342/* rtems_clock_get */
343
344      Timer_initialize();
345         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
346            (void) rtems_clock_get( options, time );
347      end_time = Read_timer();
348
349      put_time(
350         "rtems_clock_get",
351         end_time,
352         OPERATION_COUNT,
353         overhead,
354         0
355      );
356
357/* rtems_clock_set */
358
359      Timer_initialize();
360         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
361            (void) rtems_clock_set( time );
362      end_time = Read_timer();
363
364      put_time(
365         "rtems_clock_set",
366         end_time,
367         OPERATION_COUNT,
368         overhead,
369         0
370      );
371
372/* rtems_clock_tick */
373
374      Timer_initialize();
375         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
376           (void) rtems_clock_tick();
377      end_time = Read_timer();
378
379      put_time(
380         "rtems_clock_tick",
381         end_time,
382         OPERATION_COUNT,
383         overhead,
384         0
385      );
386
387rtems_test_pause();
388
389/* rtems_timer_create */
390
391      Timer_initialize();
392         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
393            (void) rtems_timer_create( name, &id );
394      end_time = Read_timer();
395
396      put_time(
397         "rtems_timer_create",
398         end_time,
399         OPERATION_COUNT,
400         overhead,
401         0
402      );
403
404/* rtems_timer_delete */
405
406      Timer_initialize();
407         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
408            (void) rtems_timer_delete( id );
409      end_time = Read_timer();
410
411      put_time(
412         "rtems_timer_delete",
413         end_time,
414         OPERATION_COUNT,
415         overhead,
416         0
417      );
418
419/* rtems_timer_ident */
420
421      Timer_initialize();
422         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
423            (void) rtems_timer_ident( name, id );
424      end_time = Read_timer();
425
426      put_time(
427         "rtems_timer_ident",
428         end_time,
429         OPERATION_COUNT,
430         overhead,
431         0
432      );
433
434/* rtems_timer_fire_after */
435
436      Timer_initialize();
437         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
438            (void) rtems_timer_fire_after(
439               id,
440               timeout,
441               Timer_handler,
442               NULL
443            );
444      end_time = Read_timer();
445
446      put_time(
447         "rtems_timer_fire_after",
448         end_time,
449         OPERATION_COUNT,
450         overhead,
451         0
452      );
453
454/* rtems_timer_fire_when */
455
456      Timer_initialize();
457         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
458            (void) rtems_timer_fire_when(
459               id,
460               time,
461               Timer_handler,
462               NULL
463            );
464      end_time = Read_timer();
465
466      put_time(
467         "rtems_timer_fire_when",
468         end_time,
469         OPERATION_COUNT,
470         overhead,
471         0
472      );
473
474/* rtems_timer_reset */
475
476      Timer_initialize();
477         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
478            (void) rtems_timer_reset( id );
479      end_time = Read_timer();
480
481      put_time(
482         "rtems_timer_reset",
483         end_time,
484         OPERATION_COUNT,
485         overhead,
486         0
487      );
488
489/* rtems_timer_cancel */
490
491      Timer_initialize();
492         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
493            (void) rtems_timer_cancel( id );
494      end_time = Read_timer();
495
496      put_time(
497         "rtems_timer_cancel",
498         end_time,
499         OPERATION_COUNT,
500         overhead,
501         0
502      );
503
504/* rtems_semaphore_create */
505
506      Timer_initialize();
507         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
508            (void) rtems_semaphore_create(
509               name,
510               128,
511               RTEMS_DEFAULT_ATTRIBUTES,
512               RTEMS_NO_PRIORITY,
513               &id
514            );
515      end_time = Read_timer();
516
517      put_time(
518         "rtems_semaphore_create",
519         end_time,
520         OPERATION_COUNT,
521         overhead,
522         0
523      );
524
525/* rtems_semaphore_delete */
526
527      Timer_initialize();
528         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
529            (void) rtems_semaphore_delete( id );
530      end_time = Read_timer();
531
532      put_time(
533         "rtems_semaphore_delete",
534         end_time,
535         OPERATION_COUNT,
536         overhead,
537         0
538      );
539
540/* rtems_semaphore_ident */
541
542      Timer_initialize();
543         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
544            (void) rtems_semaphore_ident( name, RTEMS_SEARCH_ALL_NODES, id );
545      end_time = Read_timer();
546
547      put_time(
548         "rtems_semaphore_ident",
549         end_time,
550         OPERATION_COUNT,
551         overhead,
552         0
553      );
554
555/* rtems_semaphore_obtain */
556
557      Timer_initialize();
558         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
559            (void) rtems_semaphore_obtain( id, RTEMS_DEFAULT_OPTIONS, timeout );
560      end_time = Read_timer();
561
562      put_time(
563         "rtems_semaphore_obtain",
564         end_time,
565         OPERATION_COUNT,
566         overhead,
567         0
568      );
569
570/* rtems_semaphore_release */
571
572      Timer_initialize();
573         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
574            (void) rtems_semaphore_release( id );
575      end_time = Read_timer();
576
577      put_time(
578         "rtems_semaphore_release",
579         end_time,
580         OPERATION_COUNT,
581         overhead,
582         0
583      );
584
585/* rtems_message_queue_create */
586
587      Timer_initialize();
588         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
589            (void) rtems_message_queue_create(
590               name,
591               128,
592               RTEMS_DEFAULT_ATTRIBUTES,
593               &id
594            );
595      end_time = Read_timer();
596
597      put_time(
598         "rtems_message_queue_create",
599         end_time,
600         OPERATION_COUNT,
601         overhead,
602         0
603      );
604
605/* rtems_message_queue_ident */
606
607      Timer_initialize();
608         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
609            (void) rtems_message_queue_ident(
610              name,
611              RTEMS_SEARCH_ALL_NODES,
612              id
613            );
614      end_time = Read_timer();
615
616      put_time(
617         "rtems_message_queue_ident",
618         end_time,
619         OPERATION_COUNT,
620         overhead,
621         0
622      );
623
624/* rtems_message_queue_delete */
625
626      Timer_initialize();
627         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
628            (void) rtems_message_queue_delete( id );
629      end_time = Read_timer();
630
631      put_time(
632         "rtems_message_queue_delete",
633         end_time,
634         OPERATION_COUNT,
635         overhead,
636         0
637      );
638
639/* rtems_message_queue_send */
640
641      Timer_initialize();
642         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
643            (void) rtems_message_queue_send( id, (long (*)[4])buffer );
644      end_time = Read_timer();
645
646      put_time(
647         "rtems_message_queue_send",
648         end_time,
649         OPERATION_COUNT,
650         overhead,
651         0
652      );
653
654/* rtems_message_queue_urgent */
655
656      Timer_initialize();
657         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
658            (void) rtems_message_queue_urgent( id, (long (*)[4])buffer );
659      end_time = Read_timer();
660
661      put_time(
662         "rtems_message_queue_urgent",
663         end_time,
664         OPERATION_COUNT,
665         overhead,
666         0
667      );
668
669/* rtems_message_queue_broadcast */
670
671      Timer_initialize();
672         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
673            (void) rtems_message_queue_broadcast(
674               id,
675               (long (*)[4])buffer,
676               &count
677            );
678      end_time = Read_timer();
679
680      put_time(
681         "rtems_message_queue_broadcast",
682         end_time,
683         OPERATION_COUNT,
684         overhead,
685         0
686      );
687
688/* rtems_message_queue_receive */
689
690      Timer_initialize();
691         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
692            (void) rtems_message_queue_receive(
693               id,
694               (long (*)[4])buffer,
695               RTEMS_DEFAULT_OPTIONS,
696               timeout
697            );
698      end_time = Read_timer();
699
700      put_time(
701         "rtems_message_queue_receive",
702         end_time,
703         OPERATION_COUNT,
704         overhead,
705         0
706      );
707
708/* rtems_message_queue_flush */
709
710      Timer_initialize();
711         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
712            (void) rtems_message_queue_flush( id, &count );
713      end_time = Read_timer();
714
715      put_time(
716         "rtems_message_queue_flush",
717         end_time,
718         OPERATION_COUNT,
719         overhead,
720         0
721      );
722
723rtems_test_pause();
724
725/* rtems_event_send */
726
727      Timer_initialize();
728         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
729            (void) rtems_event_send( id, events );
730      end_time = Read_timer();
731
732      put_time(
733         "rtems_event_send",
734         end_time,
735         OPERATION_COUNT,
736         overhead,
737         0
738      );
739
740/* rtems_event_receive */
741
742      Timer_initialize();
743         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
744            (void) rtems_event_receive(
745               RTEMS_EVENT_16,
746               RTEMS_DEFAULT_OPTIONS,
747               timeout,
748               &events
749            );
750      end_time = Read_timer();
751
752      put_time(
753         "rtems_event_receive",
754         end_time,
755         OPERATION_COUNT,
756         overhead,
757         0
758      );
759
760/* rtems_signal_catch */
761
762      Timer_initialize();
763         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
764            (void) rtems_signal_catch( Asr_handler, RTEMS_DEFAULT_MODES );
765      end_time = Read_timer();
766
767      put_time(
768         "rtems_signal_catch",
769         end_time,
770         OPERATION_COUNT,
771         overhead,
772         0
773      );
774
775/* rtems_signal_send */
776
777      Timer_initialize();
778         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
779            (void) rtems_signal_send( id, signals );
780      end_time = Read_timer();
781
782      put_time(
783         "rtems_signal_send",
784         end_time,
785         OPERATION_COUNT,
786         overhead,
787         0
788      );
789
790/* rtems_partition_create */
791
792      Timer_initialize();
793         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
794            (void) rtems_partition_create(
795               name,
796               Memory_area,
797               2048,
798               128,
799               RTEMS_DEFAULT_ATTRIBUTES,
800               &id
801            );
802      end_time = Read_timer();
803
804      put_time(
805         "rtems_partition_create",
806         end_time,
807         OPERATION_COUNT,
808         overhead,
809         0
810      );
811
812/* rtems_partition_ident */
813
814      Timer_initialize();
815         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
816            (void) rtems_partition_ident( name, RTEMS_SEARCH_ALL_NODES, id );
817      end_time = Read_timer();
818
819      put_time(
820         "rtems_partition_ident",
821         end_time,
822         OPERATION_COUNT,
823         overhead,
824         0
825      );
826
827/* rtems_partition_delete */
828
829      Timer_initialize();
830         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
831            (void) rtems_partition_delete( id );
832      end_time = Read_timer();
833
834      put_time(
835         "rtems_partition_delete",
836         end_time,
837         OPERATION_COUNT,
838         overhead,
839         0
840      );
841
842/* rtems_partition_get_buffer */
843
844      Timer_initialize();
845         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
846            (void) rtems_partition_get_buffer( id, address_1 );
847      end_time = Read_timer();
848
849      put_time(
850         "rtems_partition_get_buffer",
851         end_time,
852         OPERATION_COUNT,
853         overhead,
854         0
855      );
856
857/* rtems_partition_return_buffer */
858
859      Timer_initialize();
860         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
861            (void) rtems_partition_return_buffer( id, address_1 );
862      end_time = Read_timer();
863
864      put_time(
865         "rtems_partition_return_buffer",
866         end_time,
867         OPERATION_COUNT,
868         overhead,
869         0
870      );
871
872/* rtems_region_create */
873
874      Timer_initialize();
875         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
876            (void) rtems_region_create(
877               name,
878               Memory_area,
879               2048,
880               128,
881               RTEMS_DEFAULT_ATTRIBUTES,
882               &id
883            );
884      end_time = Read_timer();
885
886      put_time(
887         "rtems_region_create",
888         end_time,
889         OPERATION_COUNT,
890         overhead,
891         0
892      );
893
894/* rtems_region_ident */
895
896      Timer_initialize();
897         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
898            (void) rtems_region_ident( name, id );
899      end_time = Read_timer();
900
901      put_time(
902         "rtems_region_ident",
903         end_time,
904         OPERATION_COUNT,
905         overhead,
906         0
907      );
908
909/* rtems_region_delete */
910
911      Timer_initialize();
912         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
913            (void) rtems_region_delete( id );
914      end_time = Read_timer();
915
916      put_time(
917         "rtems_region_delete",
918         end_time,
919         OPERATION_COUNT,
920         overhead,
921         0
922      );
923
924/* rtems_region_get_segment */
925
926      Timer_initialize();
927         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
928            (void) rtems_region_get_segment(
929               id,
930               243,
931               RTEMS_DEFAULT_OPTIONS,
932               timeout,
933               &address_1
934            );
935      end_time = Read_timer();
936
937      put_time(
938         "rtems_region_get_segment",
939         end_time,
940         OPERATION_COUNT,
941         overhead,
942         0
943      );
944
945/* rtems_region_return_segment */
946
947      Timer_initialize();
948         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
949            (void) rtems_region_return_segment( id, address_1 );
950      end_time = Read_timer();
951
952      put_time(
953         "rtems_region_return_segment",
954         end_time,
955         OPERATION_COUNT,
956         overhead,
957         0
958      );
959
960/* rtems_port_create */
961
962      Timer_initialize();
963         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
964            (void) rtems_port_create(
965               name,
966               Internal_port_area,
967               External_port_area,
968               0xff,
969               &id
970            );
971      end_time = Read_timer();
972
973      put_time(
974         "rtems_port_create",
975         end_time,
976         OPERATION_COUNT,
977         overhead,
978         0
979      );
980
981/* rtems_port_ident */
982
983      Timer_initialize();
984         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
985            (void) rtems_port_ident( name, id );
986      end_time = Read_timer();
987
988      put_time(
989         "rtems_port_ident",
990         end_time,
991         OPERATION_COUNT,
992         overhead,
993         0
994      );
995
996/* rtems_port_delete */
997
998      Timer_initialize();
999         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1000            (void) rtems_port_delete( id );
1001      end_time = Read_timer();
1002
1003      put_time(
1004         "rtems_port_delete",
1005         end_time,
1006         OPERATION_COUNT,
1007         overhead,
1008         0
1009      );
1010
1011/* rtems_port_external_to_internal */
1012
1013      Timer_initialize();
1014         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1015            (void) rtems_port_external_to_internal(
1016               id,
1017               &External_port_area[ 7 ],
1018               address_1
1019            );
1020      end_time = Read_timer();
1021
1022      put_time(
1023         "rtems_port_external_to_internal",
1024         end_time,
1025         OPERATION_COUNT,
1026         overhead,
1027         0
1028      );
1029
1030/* rtems_port_internal_to_external */
1031
1032      Timer_initialize();
1033         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1034            (void) rtems_port_internal_to_external(
1035               id,
1036               &Internal_port_area[ 7 ],
1037               address_1
1038            );
1039      end_time = Read_timer();
1040
1041      put_time(
1042         "rtems_port_internal_to_external",
1043         end_time,
1044         OPERATION_COUNT,
1045         overhead,
1046         0
1047      );
1048
1049rtems_test_pause();
1050
1051/* rtems_io_initialize */
1052
1053      Timer_initialize();
1054         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1055            (void) rtems_io_initialize(
1056               major,
1057               minor,
1058               address_1,
1059               &io_result
1060            );
1061      end_time = Read_timer();
1062
1063      put_time(
1064         "rtems_io_initialize",
1065         end_time,
1066         OPERATION_COUNT,
1067         overhead,
1068         0
1069      );
1070
1071/* rtems_io_open */
1072
1073      Timer_initialize();
1074         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1075            (void) rtems_io_open(
1076               major,
1077               minor,
1078               address_1,
1079               &io_result
1080            );
1081      end_time = Read_timer();
1082
1083      put_time(
1084         "rtems_io_open",
1085         end_time,
1086         OPERATION_COUNT,
1087         overhead,
1088         0
1089      );
1090
1091/* rtems_io_close */
1092
1093      Timer_initialize();
1094         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1095            (void) rtems_io_close(
1096               major,
1097               minor,
1098               address_1,
1099               &io_result
1100            );
1101      end_time = Read_timer();
1102
1103      put_time(
1104         "rtems_io_close",
1105         end_time,
1106         OPERATION_COUNT,
1107         overhead,
1108         0
1109      );
1110
1111/* rtems_io_read */
1112
1113      Timer_initialize();
1114         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1115            (void) rtems_io_read(
1116               major,
1117               minor,
1118               address_1,
1119               &io_result
1120            );
1121      end_time = Read_timer();
1122
1123      put_time(
1124         "rtems_io_read",
1125         end_time,
1126         OPERATION_COUNT,
1127         overhead,
1128         0
1129      );
1130
1131/* rtems_io_write */
1132
1133      Timer_initialize();
1134         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1135            (void) rtems_io_write(
1136               major,
1137               minor,
1138               address_1,
1139               &io_result
1140            );
1141      end_time = Read_timer();
1142
1143      put_time(
1144         "rtems_io_write",
1145         end_time,
1146         OPERATION_COUNT,
1147         overhead,
1148         0
1149      );
1150
1151/* rtems_io_control */
1152
1153      Timer_initialize();
1154         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1155            (void) rtems_io_control(
1156               major,
1157               minor,
1158               address_1,
1159               &io_result
1160            );
1161      end_time = Read_timer();
1162
1163      put_time(
1164         "rtems_io_control",
1165         end_time,
1166         OPERATION_COUNT,
1167         overhead,
1168         0
1169      );
1170
1171/* rtems_fatal_error_occurred */
1172
1173      Timer_initialize();
1174         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1175            (void) rtems_fatal_error_occurred( error );
1176      end_time = Read_timer();
1177
1178      put_time(
1179         "rtems_fatal_error_occurred",
1180         end_time,
1181         OPERATION_COUNT,
1182         overhead,
1183         0
1184      );
1185
1186/* rtems_rate_monotonic_create */
1187
1188      Timer_initialize();
1189         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1190            (void) rtems_rate_monotonic_create( name, &id );
1191      end_time = Read_timer();
1192
1193      put_time(
1194         "rtems_rate_monotonic_create",
1195         end_time,
1196         OPERATION_COUNT,
1197         overhead,
1198         0
1199      );
1200
1201/* rtems_rate_monotonic_ident */
1202
1203      Timer_initialize();
1204         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1205            (void) rtems_rate_monotonic_ident( name, id );
1206      end_time = Read_timer();
1207
1208      put_time(
1209         "rtems_rate_monotonic_ident",
1210         end_time,
1211         OPERATION_COUNT,
1212         overhead,
1213         0
1214      );
1215
1216/* rtems_rate_monotonic_delete */
1217
1218      Timer_initialize();
1219         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1220            (void) rtems_rate_monotonic_delete( id );
1221      end_time = Read_timer();
1222
1223      put_time(
1224         "rtems_rate_monotonic_delete",
1225         end_time,
1226         OPERATION_COUNT,
1227         overhead,
1228         0
1229      );
1230
1231/* rtems_rate_monotonic_cancel */
1232
1233      Timer_initialize();
1234         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1235            (void) rtems_rate_monotonic_cancel( id );
1236      end_time = Read_timer();
1237
1238      put_time(
1239         "rtems_rate_monotonic_cancel",
1240         end_time,
1241         OPERATION_COUNT,
1242         overhead,
1243         0
1244      );
1245
1246/* rtems_rate_monotonic_period */
1247
1248      Timer_initialize();
1249         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1250            (void) rtems_rate_monotonic_period( id, timeout );
1251      end_time = Read_timer();
1252
1253      put_time(
1254         "rtems_rate_monotonic_period",
1255         end_time,
1256         OPERATION_COUNT,
1257         overhead,
1258         0
1259      );
1260
1261/* rtems_multiprocessing_announce */
1262
1263      Timer_initialize();
1264         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1265            (void) rtems_multiprocessing_announce();
1266      end_time = Read_timer();
1267
1268      put_time(
1269         "rtems_multiprocessing_announce",
1270         end_time,
1271         OPERATION_COUNT,
1272         overhead,
1273         0
1274      );
1275
1276  puts( "*** END OF TIME OVERHEAD ***" );
1277
1278  exit( 0 );
1279}
Note: See TracBrowser for help on using the repository browser.