source: rtems/testsuites/tmtests/tmoverhd/testtask.c @ 0eef698f

4.104.114.84.9
Last change on this file since 0eef698f was 0720ff4, checked in by Ralf Corsepius <ralf.corsepius@…>, on Mar 28, 2004 at 7:20:11 AM

2004-03-28 Ralf Corsepius <ralf_corsepius@…>

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