source: rtems/testsuites/tmtests/tmoverhd/testtask.c @ 7f6a24ab

4.104.114.84.95
Last change on this file since 7f6a24ab was 7f6a24ab, checked in by Joel Sherrill <joel.sherrill@…>, on Aug 28, 1995 at 3:30:29 PM

Added unused priority ceiling parameter to rtems_semaphore_create.

Rearranged code to created thread handler routines to initialize,
start, restart, and "close/delete" a thread.

Made internal threads their own object class. This now uses the
thread support routines for starting and initializing a thread.

Insured deleted tasks are freed to the Inactive pool associated with the
correct Information block.

Added an RTEMS API specific data area to the thread control block.

Beginnings of removing the word "rtems" from the core.

  • Property mode set to 100644
File size: 28.6 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               RTEMS_NO_PRIORITY,
514               &id
515            );
516      end_time = Read_timer();
517
518      put_time(
519         "rtems_semaphore_create",
520         end_time,
521         OPERATION_COUNT,
522         overhead,
523         0
524      );
525
526/* rtems_semaphore_delete */
527
528      Timer_initialize();
529         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
530            (void) rtems_semaphore_delete( id );
531      end_time = Read_timer();
532
533      put_time(
534         "rtems_semaphore_delete",
535         end_time,
536         OPERATION_COUNT,
537         overhead,
538         0
539      );
540
541/* rtems_semaphore_ident */
542
543      Timer_initialize();
544         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
545            (void) rtems_semaphore_ident( name, RTEMS_SEARCH_ALL_NODES, id );
546      end_time = Read_timer();
547
548      put_time(
549         "rtems_semaphore_ident",
550         end_time,
551         OPERATION_COUNT,
552         overhead,
553         0
554      );
555
556/* rtems_semaphore_obtain */
557
558      Timer_initialize();
559         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
560            (void) rtems_semaphore_obtain( id, RTEMS_DEFAULT_OPTIONS, timeout );
561      end_time = Read_timer();
562
563      put_time(
564         "rtems_semaphore_obtain",
565         end_time,
566         OPERATION_COUNT,
567         overhead,
568         0
569      );
570
571/* rtems_semaphore_release */
572
573      Timer_initialize();
574         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
575            (void) rtems_semaphore_release( id );
576      end_time = Read_timer();
577
578      put_time(
579         "rtems_semaphore_release",
580         end_time,
581         OPERATION_COUNT,
582         overhead,
583         0
584      );
585
586/* rtems_message_queue_create */
587
588      Timer_initialize();
589         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
590            (void) rtems_message_queue_create(
591               name,
592               128,
593               RTEMS_DEFAULT_ATTRIBUTES,
594               &id
595            );
596      end_time = Read_timer();
597
598      put_time(
599         "rtems_message_queue_create",
600         end_time,
601         OPERATION_COUNT,
602         overhead,
603         0
604      );
605
606/* rtems_message_queue_ident */
607
608      Timer_initialize();
609         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
610            (void) rtems_message_queue_ident(
611              name,
612              RTEMS_SEARCH_ALL_NODES,
613              id
614            );
615      end_time = Read_timer();
616
617      put_time(
618         "rtems_message_queue_ident",
619         end_time,
620         OPERATION_COUNT,
621         overhead,
622         0
623      );
624
625/* rtems_message_queue_delete */
626
627      Timer_initialize();
628         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
629            (void) rtems_message_queue_delete( id );
630      end_time = Read_timer();
631
632      put_time(
633         "rtems_message_queue_delete",
634         end_time,
635         OPERATION_COUNT,
636         overhead,
637         0
638      );
639
640/* rtems_message_queue_send */
641
642      Timer_initialize();
643         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
644            (void) rtems_message_queue_send( id, (long (*)[4])buffer );
645      end_time = Read_timer();
646
647      put_time(
648         "rtems_message_queue_send",
649         end_time,
650         OPERATION_COUNT,
651         overhead,
652         0
653      );
654
655/* rtems_message_queue_urgent */
656
657      Timer_initialize();
658         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
659            (void) rtems_message_queue_urgent( id, (long (*)[4])buffer );
660      end_time = Read_timer();
661
662      put_time(
663         "rtems_message_queue_urgent",
664         end_time,
665         OPERATION_COUNT,
666         overhead,
667         0
668      );
669
670/* rtems_message_queue_broadcast */
671
672      Timer_initialize();
673         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
674            (void) rtems_message_queue_broadcast(
675               id,
676               (long (*)[4])buffer,
677               &count
678            );
679      end_time = Read_timer();
680
681      put_time(
682         "rtems_message_queue_broadcast",
683         end_time,
684         OPERATION_COUNT,
685         overhead,
686         0
687      );
688
689/* rtems_message_queue_receive */
690
691      Timer_initialize();
692         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
693            (void) rtems_message_queue_receive(
694               id,
695               (long (*)[4])buffer,
696               RTEMS_DEFAULT_OPTIONS,
697               timeout
698            );
699      end_time = Read_timer();
700
701      put_time(
702         "rtems_message_queue_receive",
703         end_time,
704         OPERATION_COUNT,
705         overhead,
706         0
707      );
708
709/* rtems_message_queue_flush */
710
711      Timer_initialize();
712         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
713            (void) rtems_message_queue_flush( id, &count );
714      end_time = Read_timer();
715
716      put_time(
717         "rtems_message_queue_flush",
718         end_time,
719         OPERATION_COUNT,
720         overhead,
721         0
722      );
723
724pause();
725
726/* rtems_event_send */
727
728      Timer_initialize();
729         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
730            (void) rtems_event_send( id, events );
731      end_time = Read_timer();
732
733      put_time(
734         "rtems_event_send",
735         end_time,
736         OPERATION_COUNT,
737         overhead,
738         0
739      );
740
741/* rtems_event_receive */
742
743      Timer_initialize();
744         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
745            (void) rtems_event_receive(
746               RTEMS_EVENT_16,
747               RTEMS_DEFAULT_OPTIONS,
748               timeout,
749               &events
750            );
751      end_time = Read_timer();
752
753      put_time(
754         "rtems_event_receive",
755         end_time,
756         OPERATION_COUNT,
757         overhead,
758         0
759      );
760
761/* rtems_signal_catch */
762
763      Timer_initialize();
764         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
765            (void) rtems_signal_catch( Asr_handler, RTEMS_DEFAULT_MODES );
766      end_time = Read_timer();
767
768      put_time(
769         "rtems_signal_catch",
770         end_time,
771         OPERATION_COUNT,
772         overhead,
773         0
774      );
775
776/* rtems_signal_send */
777
778      Timer_initialize();
779         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
780            (void) rtems_signal_send( id, signals );
781      end_time = Read_timer();
782
783      put_time(
784         "rtems_signal_send",
785         end_time,
786         OPERATION_COUNT,
787         overhead,
788         0
789      );
790
791/* rtems_partition_create */
792
793      Timer_initialize();
794         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
795            (void) rtems_partition_create(
796               name,
797               Memory_area,
798               2048,
799               128,
800               RTEMS_DEFAULT_ATTRIBUTES,
801               &id
802            );
803      end_time = Read_timer();
804
805      put_time(
806         "rtems_partition_create",
807         end_time,
808         OPERATION_COUNT,
809         overhead,
810         0
811      );
812
813/* rtems_partition_ident */
814
815      Timer_initialize();
816         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
817            (void) rtems_partition_ident( name, RTEMS_SEARCH_ALL_NODES, id );
818      end_time = Read_timer();
819
820      put_time(
821         "rtems_partition_ident",
822         end_time,
823         OPERATION_COUNT,
824         overhead,
825         0
826      );
827
828/* rtems_partition_delete */
829
830      Timer_initialize();
831         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
832            (void) rtems_partition_delete( id );
833      end_time = Read_timer();
834
835      put_time(
836         "rtems_partition_delete",
837         end_time,
838         OPERATION_COUNT,
839         overhead,
840         0
841      );
842
843/* rtems_partition_get_buffer */
844
845      Timer_initialize();
846         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
847            (void) rtems_partition_get_buffer( id, address_1 );
848      end_time = Read_timer();
849
850      put_time(
851         "rtems_partition_get_buffer",
852         end_time,
853         OPERATION_COUNT,
854         overhead,
855         0
856      );
857
858/* rtems_partition_return_buffer */
859
860      Timer_initialize();
861         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
862            (void) rtems_partition_return_buffer( id, address_1 );
863      end_time = Read_timer();
864
865      put_time(
866         "rtems_partition_return_buffer",
867         end_time,
868         OPERATION_COUNT,
869         overhead,
870         0
871      );
872
873/* rtems_region_create */
874
875      Timer_initialize();
876         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
877            (void) rtems_region_create(
878               name,
879               Memory_area,
880               2048,
881               128,
882               RTEMS_DEFAULT_ATTRIBUTES,
883               &id
884            );
885      end_time = Read_timer();
886
887      put_time(
888         "rtems_region_create",
889         end_time,
890         OPERATION_COUNT,
891         overhead,
892         0
893      );
894
895/* rtems_region_ident */
896
897      Timer_initialize();
898         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
899            (void) rtems_region_ident( name, id );
900      end_time = Read_timer();
901
902      put_time(
903         "rtems_region_ident",
904         end_time,
905         OPERATION_COUNT,
906         overhead,
907         0
908      );
909
910/* rtems_region_delete */
911
912      Timer_initialize();
913         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
914            (void) rtems_region_delete( id );
915      end_time = Read_timer();
916
917      put_time(
918         "rtems_region_delete",
919         end_time,
920         OPERATION_COUNT,
921         overhead,
922         0
923      );
924
925/* rtems_region_get_segment */
926
927      Timer_initialize();
928         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
929            (void) rtems_region_get_segment(
930               id,
931               243,
932               RTEMS_DEFAULT_OPTIONS,
933               timeout,
934               &address_1
935            );
936      end_time = Read_timer();
937
938      put_time(
939         "rtems_region_get_segment",
940         end_time,
941         OPERATION_COUNT,
942         overhead,
943         0
944      );
945
946/* rtems_region_return_segment */
947
948      Timer_initialize();
949         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
950            (void) rtems_region_return_segment( id, address_1 );
951      end_time = Read_timer();
952
953      put_time(
954         "rtems_region_return_segment",
955         end_time,
956         OPERATION_COUNT,
957         overhead,
958         0
959      );
960
961/* rtems_port_create */
962
963      Timer_initialize();
964         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
965            (void) rtems_port_create(
966               name,
967               Internal_port_area,
968               External_port_area,
969               0xff,
970               &id
971            );
972      end_time = Read_timer();
973
974      put_time(
975         "rtems_port_create",
976         end_time,
977         OPERATION_COUNT,
978         overhead,
979         0
980      );
981
982/* rtems_port_ident */
983
984      Timer_initialize();
985         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
986            (void) rtems_port_ident( name, id );
987      end_time = Read_timer();
988
989      put_time(
990         "rtems_port_ident",
991         end_time,
992         OPERATION_COUNT,
993         overhead,
994         0
995      );
996
997/* rtems_port_delete */
998
999      Timer_initialize();
1000         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1001            (void) rtems_port_delete( id );
1002      end_time = Read_timer();
1003
1004      put_time(
1005         "rtems_port_delete",
1006         end_time,
1007         OPERATION_COUNT,
1008         overhead,
1009         0
1010      );
1011
1012/* rtems_port_external_to_internal */
1013
1014      Timer_initialize();
1015         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1016            (void) rtems_port_external_to_internal(
1017               id,
1018               &External_port_area[ 7 ],
1019               address_1
1020            );
1021      end_time = Read_timer();
1022
1023      put_time(
1024         "rtems_port_external_to_internal",
1025         end_time,
1026         OPERATION_COUNT,
1027         overhead,
1028         0
1029      );
1030
1031/* rtems_port_internal_to_external */
1032
1033      Timer_initialize();
1034         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1035            (void) rtems_port_internal_to_external(
1036               id,
1037               &Internal_port_area[ 7 ],
1038               address_1
1039            );
1040      end_time = Read_timer();
1041
1042      put_time(
1043         "rtems_port_internal_to_external",
1044         end_time,
1045         OPERATION_COUNT,
1046         overhead,
1047         0
1048      );
1049
1050pause();
1051
1052/* rtems_io_initialize */
1053
1054      Timer_initialize();
1055         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1056            (void) rtems_io_initialize(
1057               major,
1058               minor,
1059               address_1,
1060               &io_result
1061            );
1062      end_time = Read_timer();
1063
1064      put_time(
1065         "rtems_io_initialize",
1066         end_time,
1067         OPERATION_COUNT,
1068         overhead,
1069         0
1070      );
1071
1072/* rtems_io_open */
1073
1074      Timer_initialize();
1075         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1076            (void) rtems_io_open(
1077               major,
1078               minor,
1079               address_1,
1080               &io_result
1081            );
1082      end_time = Read_timer();
1083
1084      put_time(
1085         "rtems_io_open",
1086         end_time,
1087         OPERATION_COUNT,
1088         overhead,
1089         0
1090      );
1091
1092/* rtems_io_close */
1093
1094      Timer_initialize();
1095         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1096            (void) rtems_io_close(
1097               major,
1098               minor,
1099               address_1,
1100               &io_result
1101            );
1102      end_time = Read_timer();
1103
1104      put_time(
1105         "rtems_io_close",
1106         end_time,
1107         OPERATION_COUNT,
1108         overhead,
1109         0
1110      );
1111
1112/* rtems_io_read */
1113
1114      Timer_initialize();
1115         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1116            (void) rtems_io_read(
1117               major,
1118               minor,
1119               address_1,
1120               &io_result
1121            );
1122      end_time = Read_timer();
1123
1124      put_time(
1125         "rtems_io_read",
1126         end_time,
1127         OPERATION_COUNT,
1128         overhead,
1129         0
1130      );
1131
1132/* rtems_io_write */
1133
1134      Timer_initialize();
1135         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1136            (void) rtems_io_write(
1137               major,
1138               minor,
1139               address_1,
1140               &io_result
1141            );
1142      end_time = Read_timer();
1143
1144      put_time(
1145         "rtems_io_write",
1146         end_time,
1147         OPERATION_COUNT,
1148         overhead,
1149         0
1150      );
1151
1152/* rtems_io_control */
1153
1154      Timer_initialize();
1155         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1156            (void) rtems_io_control(
1157               major,
1158               minor,
1159               address_1,
1160               &io_result
1161            );
1162      end_time = Read_timer();
1163
1164      put_time(
1165         "rtems_io_control",
1166         end_time,
1167         OPERATION_COUNT,
1168         overhead,
1169         0
1170      );
1171
1172/* rtems_fatal_error_occurred */
1173
1174      Timer_initialize();
1175         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1176            (void) rtems_fatal_error_occurred( error );
1177      end_time = Read_timer();
1178
1179      put_time(
1180         "rtems_fatal_error_occurred",
1181         end_time,
1182         OPERATION_COUNT,
1183         overhead,
1184         0
1185      );
1186
1187/* rtems_rate_monotonic_create */
1188
1189      Timer_initialize();
1190         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1191            (void) rtems_rate_monotonic_create( name, &id );
1192      end_time = Read_timer();
1193
1194      put_time(
1195         "rtems_rate_monotonic_create",
1196         end_time,
1197         OPERATION_COUNT,
1198         overhead,
1199         0
1200      );
1201
1202/* rtems_rate_monotonic_ident */
1203
1204      Timer_initialize();
1205         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1206            (void) rtems_rate_monotonic_ident( name, id );
1207      end_time = Read_timer();
1208
1209      put_time(
1210         "rtems_rate_monotonic_ident",
1211         end_time,
1212         OPERATION_COUNT,
1213         overhead,
1214         0
1215      );
1216
1217/* rtems_rate_monotonic_delete */
1218
1219      Timer_initialize();
1220         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1221            (void) rtems_rate_monotonic_delete( id );
1222      end_time = Read_timer();
1223
1224      put_time(
1225         "rtems_rate_monotonic_delete",
1226         end_time,
1227         OPERATION_COUNT,
1228         overhead,
1229         0
1230      );
1231
1232/* rtems_rate_monotonic_cancel */
1233
1234      Timer_initialize();
1235         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1236            (void) rtems_rate_monotonic_cancel( id );
1237      end_time = Read_timer();
1238
1239      put_time(
1240         "rtems_rate_monotonic_cancel",
1241         end_time,
1242         OPERATION_COUNT,
1243         overhead,
1244         0
1245      );
1246
1247/* rtems_rate_monotonic_period */
1248
1249      Timer_initialize();
1250         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1251            (void) rtems_rate_monotonic_period( id, timeout );
1252      end_time = Read_timer();
1253
1254      put_time(
1255         "rtems_rate_monotonic_period",
1256         end_time,
1257         OPERATION_COUNT,
1258         overhead,
1259         0
1260      );
1261
1262/* rtems_multiprocessing_announce */
1263
1264      Timer_initialize();
1265         for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
1266            (void) rtems_multiprocessing_announce();
1267      end_time = Read_timer();
1268
1269      put_time(
1270         "rtems_multiprocessing_announce",
1271         end_time,
1272         OPERATION_COUNT,
1273         overhead,
1274         0
1275      );
1276
1277  puts( "*** END OF TIME OVERHEAD ***\n" );
1278
1279  exit( 0 );
1280}
Note: See TracBrowser for help on using the repository browser.