source: rtems/testsuites/tmtests/tmoverhd/testtask.c @ 4b374f36

4.104.114.84.95
Last change on this file since 4b374f36 was ac7d5ef0, checked in by Joel Sherrill <joel.sherrill@…>, on May 11, 1995 at 5:39:37 PM

Initial revision

  • Property mode set to 100644
File size: 28.5 KB
Line 
1/*
2 *
3 *  COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.
4 *  On-Line Applications Research Corporation (OAR).
5 *  All rights assigned to U.S. Government, 1994.
6 *
7 *  This material may be reproduced by or for the U.S. Government pursuant
8 *  to the copyright license under the clause at DFARS 252.227-7013.  This
9 *  notice must appear in all copies of this file and its derivatives.
10 *
11 *  $Id$
12 */
13
14#include "system.h"
15#undef EXTERN
16#define EXTERN
17#include "conftbl.h"
18#include "gvar.h"
19
20rtems_unsigned8 Memory_area[ 2048 ];
21rtems_unsigned8 Internal_port_area[ 256 ];
22rtems_unsigned8 External_port_area[ 256 ];
23
24rtems_task Task_1(
25  rtems_task_argument argument
26);
27
28rtems_task Init(
29  rtems_task_argument argument
30)
31{ rtems_id id;
32  rtems_status_code status;
33
34  Set_find_average_overhead( TRUE );
35
36  puts( "\n\n*** TIME TEST overhead ***" );
37
38  status = rtems_task_create(
39    rtems_build_name( 'T', 'A', '1', ' ' ),
40    254,
41    2048,
42    RTEMS_DEFAULT_MODES,
43    RTEMS_DEFAULT_ATTRIBUTES,
44    &id
45  );
46  directive_failed( status, "rtems_task_create of TA1" );
47
48  status = rtems_task_start( id, Task_1, 0 );
49  directive_failed( status, "rtems_task_start of TA1" );
50
51  status = rtems_task_delete( RTEMS_SELF );
52  directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
53}
54
55/* comment out the following include to verify type are correct */
56#include "dumrtems.h"
57
58rtems_task Task_1(
59  rtems_task_argument argument
60)
61{
62  rtems_name                 name;
63  rtems_unsigned32           index;
64  rtems_cpu_table            cpu_table;
65  rtems_id                   id;
66  rtems_task_priority        in_priority;
67  rtems_task_priority        out_priority;
68  rtems_mode                 in_mode;
69  rtems_mode                 mask;
70  rtems_mode                 out_mode;
71  rtems_unsigned32           note;
72  rtems_time_of_day          time;
73  rtems_interval             timeout;
74  rtems_signal_set           signals;
75  void                      *address_1;
76  rtems_event_set            events;
77  long                       buffer[ 4 ];
78  rtems_unsigned32           count;
79  rtems_device_major_number  major;
80  rtems_device_minor_number  minor;
81  rtems_unsigned32           io_result;
82  rtems_unsigned32           error;
83  rtems_clock_get_options    options;
84
85  name        = rtems_build_name( 'N', 'A', 'M', 'E' );
86  in_priority = 250;
87  in_mode     = RTEMS_NO_PREEMPT;
88  mask        = RTEMS_PREEMPT_MASK;
89  note        = 8;
90  timeout     = 100;
91  signals     = RTEMS_SIGNAL_1 | RTEMS_SIGNAL_3;
92  major       = 10;
93  minor       = 0;
94  error       = 100;
95  options     = 0;
96
97/* rtems_initialize_executive */
98  Timer_initialize();
99    for ( index=1 ; index <= OPERATION_COUNT ; index++ )
100      (void) rtems_initialize_executive( &BSP_Configuration, &cpu_table );
101  end_time = Read_timer();
102
103  put_time(
104    "rtems_initialize_executive",
105    end_time,
106    OPERATION_COUNT,
107    overhead,
108    0
109  );
110
111/* rtems_shutdown_executive */
112
113  Timer_initialize();
114    for ( index=1 ; index <= OPERATION_COUNT ; index++ )
115      (void) rtems_shutdown_executive( error );
116  end_time = Read_timer();
117
118  put_time(
119    "rtems_shutdown_executive",
120    end_time,
121    OPERATION_COUNT,
122    overhead,
123    0
124  );
125
126/* rtems_task_create */
127
128      Timer_initialize();
129         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
130            (void) rtems_task_create(
131               name,
132               in_priority,
133               2048,
134               RTEMS_DEFAULT_MODES,
135               RTEMS_DEFAULT_ATTRIBUTES,
136               &id
137            );
138      end_time = Read_timer();
139
140      put_time(
141         "rtems_task_create",
142         end_time,
143         OPERATION_COUNT,
144         overhead,
145         0
146      );
147
148/* rtems_task_ident */
149
150      Timer_initialize();
151         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
152            (void) rtems_task_ident( name, RTEMS_SEARCH_ALL_NODES, id );
153      end_time = Read_timer();
154
155      put_time(
156         "rtems_task_ident",
157         end_time,
158         OPERATION_COUNT,
159         overhead,
160         0
161      );
162
163/* rtems_task_start */
164
165      Timer_initialize();
166         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
167            (void) rtems_task_start( id, Task_1, 0 );
168      end_time = Read_timer();
169
170      put_time(
171         "rtems_task_start",
172         end_time,
173         OPERATION_COUNT,
174         overhead,
175         0
176      );
177
178/* rtems_task_restart */
179
180      Timer_initialize();
181         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
182            (void) rtems_task_restart( id, 0 );
183      end_time = Read_timer();
184
185      put_time(
186         "rtems_task_restart",
187         end_time,
188         OPERATION_COUNT,
189         overhead,
190         0
191      );
192
193/* rtems_task_delete */
194
195      Timer_initialize();
196         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
197            (void) rtems_task_delete( id );
198      end_time = Read_timer();
199
200      put_time(
201         "rtems_task_delete",
202         end_time,
203         OPERATION_COUNT,
204         overhead,
205         0
206      );
207
208/* rtems_task_suspend */
209
210      Timer_initialize();
211         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
212            (void) rtems_task_suspend( id );
213      end_time = Read_timer();
214
215      put_time(
216         "rtems_task_suspend",
217         end_time,
218         OPERATION_COUNT,
219         overhead,
220         0
221      );
222
223/* rtems_task_resume */
224
225      Timer_initialize();
226         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
227            (void) rtems_task_resume( id );
228      end_time = Read_timer();
229
230      put_time(
231         "rtems_task_resume",
232         end_time,
233         OPERATION_COUNT,
234         overhead,
235         0
236      );
237
238/* rtems_task_set_priority */
239
240      Timer_initialize();
241         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
242            (void) rtems_task_set_priority( id, in_priority, &out_priority );
243      end_time = Read_timer();
244
245      put_time(
246         "rtems_task_set_priority",
247         end_time,
248         OPERATION_COUNT,
249         overhead,
250         0
251      );
252
253/* rtems_task_mode */
254
255      Timer_initialize();
256         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
257            (void) rtems_task_mode( in_mode, mask, &out_mode );
258      end_time = Read_timer();
259
260      put_time(
261         "rtems_task_mode",
262         end_time,
263         OPERATION_COUNT,
264         overhead,
265         0
266      );
267
268/* rtems_task_get_note */
269
270      Timer_initialize();
271         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
272            (void) rtems_task_get_note( id, 1, note );
273      end_time = Read_timer();
274
275      put_time(
276         "rtems_task_get_note",
277         end_time,
278         OPERATION_COUNT,
279         overhead,
280         0
281      );
282
283/* rtems_task_set_note */
284
285      Timer_initialize();
286         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
287            (void) rtems_task_set_note( id, 1, note );
288      end_time = Read_timer();
289
290      put_time(
291         "rtems_task_set_note",
292         end_time,
293         OPERATION_COUNT,
294         overhead,
295         0
296      );
297
298/* rtems_task_wake_when */
299
300      Timer_initialize();
301         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
302            (void) rtems_task_wake_when( time );
303      end_time = Read_timer();
304
305      put_time(
306         "rtems_task_wake_when",
307         end_time,
308         OPERATION_COUNT,
309         overhead,
310         0
311      );
312
313/* rtems_task_wake_after */
314
315      Timer_initialize();
316         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
317            (void) rtems_task_wake_after( timeout );
318      end_time = Read_timer();
319
320      put_time(
321         "rtems_task_wake_after",
322         end_time,
323         OPERATION_COUNT,
324         overhead,
325         0
326      );
327
328/* rtems_interrupt_catch */
329
330      Timer_initialize();
331         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
332            (void) rtems_interrupt_catch( Isr_handler, 5, address_1 );
333      end_time = Read_timer();
334
335      put_time(
336         "rtems_interrupt_catch",
337         end_time,
338         OPERATION_COUNT,
339         overhead,
340         0
341      );
342
343/* rtems_clock_get */
344
345      Timer_initialize();
346         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
347            (void) rtems_clock_get( options, time );
348      end_time = Read_timer();
349
350      put_time(
351         "rtems_clock_get",
352         end_time,
353         OPERATION_COUNT,
354         overhead,
355         0
356      );
357
358/* rtems_clock_set */
359
360      Timer_initialize();
361         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
362            (void) rtems_clock_set( time );
363      end_time = Read_timer();
364
365      put_time(
366         "rtems_clock_set",
367         end_time,
368         OPERATION_COUNT,
369         overhead,
370         0
371      );
372
373/* rtems_clock_tick */
374
375      Timer_initialize();
376         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
377           (void) rtems_clock_tick();
378      end_time = Read_timer();
379
380      put_time(
381         "rtems_clock_tick",
382         end_time,
383         OPERATION_COUNT,
384         overhead,
385         0
386      );
387
388pause();
389
390/* rtems_timer_create */
391
392      Timer_initialize();
393         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
394            (void) rtems_timer_create( name, &id );
395      end_time = Read_timer();
396
397      put_time(
398         "rtems_timer_create",
399         end_time,
400         OPERATION_COUNT,
401         overhead,
402         0
403      );
404
405/* rtems_timer_delete */
406
407      Timer_initialize();
408         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
409            (void) rtems_timer_delete( id );
410      end_time = Read_timer();
411
412      put_time(
413         "rtems_timer_delete",
414         end_time,
415         OPERATION_COUNT,
416         overhead,
417         0
418      );
419
420/* rtems_timer_ident */
421
422      Timer_initialize();
423         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
424            (void) rtems_timer_ident( name, id );
425      end_time = Read_timer();
426
427      put_time(
428         "rtems_timer_ident",
429         end_time,
430         OPERATION_COUNT,
431         overhead,
432         0
433      );
434
435/* rtems_timer_fire_after */
436
437      Timer_initialize();
438         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
439            (void) rtems_timer_fire_after(
440               id,
441               timeout,
442               Timer_handler,
443               NULL
444            );
445      end_time = Read_timer();
446
447      put_time(
448         "rtems_timer_fire_after",
449         end_time,
450         OPERATION_COUNT,
451         overhead,
452         0
453      );
454
455/* rtems_timer_fire_when */
456
457      Timer_initialize();
458         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
459            (void) rtems_timer_fire_when(
460               id,
461               time,
462               Timer_handler,
463               NULL
464            );
465      end_time = Read_timer();
466
467      put_time(
468         "rtems_timer_fire_when",
469         end_time,
470         OPERATION_COUNT,
471         overhead,
472         0
473      );
474
475/* rtems_timer_reset */
476
477      Timer_initialize();
478         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
479            (void) rtems_timer_reset( id );
480      end_time = Read_timer();
481
482      put_time(
483         "rtems_timer_reset",
484         end_time,
485         OPERATION_COUNT,
486         overhead,
487         0
488      );
489
490/* rtems_timer_cancel */
491
492      Timer_initialize();
493         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
494            (void) rtems_timer_cancel( id );
495      end_time = Read_timer();
496
497      put_time(
498         "rtems_timer_cancel",
499         end_time,
500         OPERATION_COUNT,
501         overhead,
502         0
503      );
504
505/* rtems_semaphore_create */
506
507      Timer_initialize();
508         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
509            (void) rtems_semaphore_create(
510               name,
511               128,
512               RTEMS_DEFAULT_ATTRIBUTES,
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
723pause();
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
1049pause();
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 ***\n" );
1277
1278  exit( 0 );
1279}
Note: See TracBrowser for help on using the repository browser.