source: rtems/testsuites/tmtests/tmoverhd/testtask.c

Last change on this file was fdeaa64, checked in by Sebastian Huber <sebastian.huber@…>, on Mar 3, 2020 at 12:01:56 PM

config: Remove <rtems/btimer.h> include

The use of CONFIGURE_APPLICATION_NEEDS_TIMER_DRIVER does not define
anything, so remove the <rtems/btimer.h> include.

Update #3875.

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