source: rtems/c/src/ada-tests/mptests/mp14/mptest.adb @ 9917d5da

4.104.114.84.95
Last change on this file since 9917d5da was bf9ae83, checked in by Joel Sherrill <joel.sherrill@…>, on 06/02/97 at 20:32:11

modified copyright notice to be the same as RTEMS 4.0.0.

changed the CVS ID string to be a "development" version.

  • Property mode set to 100644
File size: 18.9 KB
Line 
1--
2--  MPTEST / BODY
3--
4--  DESCRIPTION:
5--
6--  This package is the implementation for Test 14 of the RTEMS
7--  Multiprocessor Test Suite.
8--
9--  DEPENDENCIES:
10--
11--
12--
13--  COPYRIGHT (c) 1989-1997.
14--  On-Line Applications Research Corporation (OAR).
15--  Copyright assigned to U.S. Government, 1994.
16--
17--  The license and distribution terms for this file may in
18--  the file LICENSE in this distribution or at
19--  http://www.OARcorp.com/rtems/license.html.
20--
21--  $Id$
22--
23
24with INTERFACES; use INTERFACES;
25with BSP;
26with BSP_MPCI;
27with RTEMS;
28with TEST_SUPPORT;
29with TEXT_IO;
30with UNSIGNED32_IO;
31
32package body MPTEST is
33
34   package body PER_NODE_CONFIGURATION is separate;
35
36--PAGE
37--
38--  STOP_TEST_TSR
39--
40 
41   procedure STOP_TEST_TSR (
42      IGNORED_ID      : in     RTEMS.ID;
43      IGNORED_ADDRESS : in     RTEMS.ADDRESS
44   ) is
45   begin
46 
47      MPTEST.STOP_TEST := TRUE;
48 
49   end STOP_TEST_TSR;
50 
51--PAGE
52--
53--  EXIT_TEST
54--
55 
56   procedure EXIT_TEST is
57      OLD_MODE : RTEMS.MODE;
58      STATUS   : RTEMS.STATUS_CODES;
59   begin
60 
61      RTEMS.TASK_MODE( RTEMS.NO_PREEMPT, RTEMS.PREEMPT_MASK, OLD_MODE, STATUS );
62      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_MODE" );
63
64      BSP_MPCI.PRINT_STATISTICS;
65
66      RTEMS.SHUTDOWN_EXECUTIVE( 0 );
67 
68   end EXIT_TEST;
69 
70--PAGE
71--
72--  INIT
73--
74
75   procedure INIT (
76      ARGUMENT : in     RTEMS.TASK_ARGUMENT
77   ) is
78      INDEX             : RTEMS.UNSIGNED32;
79      STATUS            : RTEMS.STATUS_CODES;
80      PREVIOUS_PRIORITY : RTEMS.TASK_PRIORITY;
81   begin
82
83      TEXT_IO.NEW_LINE( 2 );
84      TEXT_IO.PUT( "*** TEST 14 -- NODE " );
85      UNSIGNED32_IO.PUT(
86         MPTEST.MULTIPROCESSING_CONFIGURATION.NODE,
87         WIDTH => 1
88      );
89      TEXT_IO.PUT_LINE( " ***" );
90
91      MPTEST.STOP_TIMER_NAME := RTEMS.BUILD_NAME( 'S', 'T', 'O', 'P' );
92
93      MPTEST.STOP_TEST := FALSE;
94
95      RTEMS.TIMER_CREATE(
96         MPTEST.STOP_TIMER_NAME,
97         MPTEST.STOP_TIMER_ID,
98         STATUS
99      );
100      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TIMER_CREATE" );
101
102      RTEMS.TIMER_FIRE_AFTER(
103         MPTEST.STOP_TIMER_ID,
104         BSP.MAXIMUM_LONG_TEST_DURATION * TEST_SUPPORT.TICKS_PER_SECOND,
105         MPTEST.STOP_TEST_TSR'ACCESS,
106         RTEMS.NULL_ADDRESS,
107         STATUS
108      );
109      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TIMER_FIRE_AFTER" );
110 
111      MPTEST.EVENT_TASK_NAME( 1 ) := RTEMS.BUILD_NAME(  '1', '1', '1', ' ' );
112      MPTEST.EVENT_TASK_NAME( 2 ) := RTEMS.BUILD_NAME(  '2', '2', '2', ' ' );
113
114      MPTEST.QUEUE_TASK_NAME( 1 ) := RTEMS.BUILD_NAME(  'M', 'T', '1', ' ' );
115      MPTEST.QUEUE_TASK_NAME( 2 ) := RTEMS.BUILD_NAME(  'M', 'T', '2', ' ' );
116
117      MPTEST.PARTITION_TASK_NAME( 1 ) :=
118         RTEMS.BUILD_NAME(  'P', 'T', '1', ' ' );
119      MPTEST.PARTITION_TASK_NAME( 2 ) :=
120         RTEMS.BUILD_NAME(  'P', 'T', '2', ' ' );
121
122      MPTEST.SEMAPHORE_TASK_NAME( 1 ) :=
123         RTEMS.BUILD_NAME(  'S', 'M', '1', ' ' );
124      MPTEST.SEMAPHORE_TASK_NAME( 2 ) :=
125         RTEMS.BUILD_NAME(  'S', 'M', '2', ' ' );
126
127      MPTEST.SEMAPHORE_NAME( 1 ) := RTEMS.BUILD_NAME(  'S', 'E', 'M', ' ' );
128
129      MPTEST.QUEUE_NAME( 1 ) := RTEMS.BUILD_NAME(  'M', 'S', 'G', ' ' );
130
131      MPTEST.PARTITION_NAME( 1 ) := RTEMS.BUILD_NAME(  'P', 'A', 'R', ' ' );
132
133      MPTEST.TIMER_NAME( 1 ) := RTEMS.BUILD_NAME(  'T', 'M', 'R', ' ' );
134
135      for INDEX in MPTEST.BUFFERS'FIRST .. MPTEST.BUFFERS'LAST
136      loop
137
138         MPTEST.BUFFERS( INDEX ) :=
139            RTEMS.TO_BUFFER_POINTER( MPTEST.BUFFER_AREAS( INDEX )'ADDRESS );
140
141      end loop;
142
143      if MPTEST.MULTIPROCESSING_CONFIGURATION.NODE = 1 then
144
145         TEXT_IO.PUT_LINE( "Creating Semaphore (Global)" );
146         RTEMS.SEMAPHORE_CREATE(
147            MPTEST.SEMAPHORE_NAME( 1 ),
148            1,
149            RTEMS.GLOBAL,
150            MPTEST.SEMAPHORE_ID( 1 ),
151            STATUS
152         );
153         TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_CREATE" );
154
155         TEXT_IO.PUT_LINE( "Creating Message Queue (Global)" );
156         RTEMS.MESSAGE_QUEUE_CREATE(
157            MPTEST.QUEUE_NAME( 1 ),
158            1,
159            RTEMS.GLOBAL,
160            MPTEST.QUEUE_ID( 1 ),
161            STATUS
162         );
163         TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "MESSAGE_QUEUE_CREATE" );
164
165         TEXT_IO.PUT_LINE( "Creating Partition (Global)" );
166         RTEMS.PARTITION_CREATE(
167            MPTEST.PARTITION_NAME( 1 ),
168            MPTEST.PARTITION_AREA( 0 )'ADDRESS,
169            16#8000#,
170            16#3000#,
171            RTEMS.GLOBAL,
172            MPTEST.PARTITION_ID( 1 ),
173            STATUS
174         );
175         TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "PARTITION_CREATE" );
176
177      end if;
178
179      TEXT_IO.PUT_LINE( "Creating Event task (Global)" );
180      RTEMS.TASK_CREATE(
181         MPTEST.EVENT_TASK_NAME(
182            MPTEST.MULTIPROCESSING_CONFIGURATION.NODE
183         ),
184         2,
185         2048,
186         RTEMS.TIMESLICE,
187         RTEMS.GLOBAL,
188         MPTEST.EVENT_TASK_ID( 1 ),
189         STATUS
190      );
191      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE" );
192
193      TEXT_IO.PUT_LINE( "Starting Event task (Global)" );
194      RTEMS.TASK_START(
195         MPTEST.EVENT_TASK_ID( 1 ),
196         MPTEST.TEST_TASK'ACCESS,
197         0,
198         STATUS
199      );
200      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START" );
201
202      TEXT_IO.PUT_LINE( "Creating Semaphore task (Global)" );
203      RTEMS.TASK_CREATE(
204         MPTEST.SEMAPHORE_TASK_NAME(
205            MPTEST.MULTIPROCESSING_CONFIGURATION.NODE
206         ),
207         2,
208         2048,
209         RTEMS.TIMESLICE,
210         RTEMS.GLOBAL,
211         MPTEST.SEMAPHORE_TASK_ID( 1 ),
212         STATUS
213      );
214      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE" );
215
216      TEXT_IO.PUT_LINE( "Starting Semaphore task (Global)" );
217      RTEMS.TASK_START(
218         MPTEST.SEMAPHORE_TASK_ID( 1 ),
219         MPTEST.SEMAPHORE_TASK'ACCESS,
220         0,
221         STATUS
222      );
223      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START" );
224
225      TEXT_IO.PUT_LINE( "Creating Message Queue task (Global)" );
226      RTEMS.TASK_CREATE(
227         MPTEST.QUEUE_TASK_NAME(
228            MPTEST.MULTIPROCESSING_CONFIGURATION.NODE
229         ),
230         2,
231         2048,
232         RTEMS.TIMESLICE,
233         RTEMS.GLOBAL,
234         MPTEST.QUEUE_TASK_ID( 1 ),
235         STATUS
236      );
237      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE" );
238
239      TEXT_IO.PUT_LINE( "Starting Message Queue task (Global)" );
240      RTEMS.TASK_START(
241         MPTEST.QUEUE_TASK_ID( 1 ),
242         MPTEST.MESSAGE_QUEUE_TASK'ACCESS,
243         1,                          -- index of buffer
244         STATUS
245      );
246      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START" );
247
248      TEXT_IO.PUT_LINE( "Creating Partition task (Global)" );
249      RTEMS.TASK_CREATE(
250         MPTEST.PARTITION_TASK_NAME(
251            MPTEST.MULTIPROCESSING_CONFIGURATION.NODE
252         ),
253         2,
254         2048,
255         RTEMS.TIMESLICE,
256         RTEMS.GLOBAL,
257         MPTEST.PARTITION_TASK_ID( 1 ),
258         STATUS
259      );
260      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE" );
261
262      TEXT_IO.PUT_LINE( "Starting Partition task (Global)" );
263      RTEMS.TASK_START(
264         MPTEST.PARTITION_TASK_ID( 1 ),
265         MPTEST.PARTITION_TASK'ACCESS,
266         0,
267         STATUS
268      );
269      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START" );
270   
271      RTEMS.TASK_SET_PRIORITY( RTEMS.SELF, 2, PREVIOUS_PRIORITY, STATUS );
272      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_SET_PRIORITY" );
273
274      MPTEST.DELAYED_EVENTS_TASK( 1 );
275
276   end INIT;
277
278--
279--  DELAYED_SEND_EVENT
280--
281--  DESCRIPTION:
282--
283--  This subprogram is a timer service routine which sends an
284--  event set to a waiting task.
285--
286
287   procedure DELAYED_SEND_EVENT (
288      TIMER_ID        : in     RTEMS.ID;
289      IGNORED_ADDRESS : in     RTEMS.ADDRESS
290   ) is
291      STATUS : RTEMS.STATUS_CODES;
292   begin
293
294      RTEMS.EVENT_SEND(
295         MPTEST.TASK_ID( RTEMS.GET_INDEX( TIMER_ID ) ),
296         RTEMS.EVENT_16,
297         STATUS
298      );
299      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "EVENT_SEND" );
300
301   end DELAYED_SEND_EVENT;
302 
303--
304--  TEST_TASK
305--
306--  DESCRIPTION:
307--
308--  This is one of the test tasks.
309--
310 
311   procedure TEST_TASK (
312      ARGUMENT : in     RTEMS.TASK_ARGUMENT
313   ) is
314      REMOTE_NODE : RTEMS.UNSIGNED32;
315      REMOTE_TID  : RTEMS.ID;
316      COUNT       : RTEMS.UNSIGNED32;
317      EVENT_OUT   : RTEMS.EVENT_SET;
318      STATUS      : RTEMS.STATUS_CODES;
319   begin
320
321      if MPTEST.MULTIPROCESSING_CONFIGURATION.NODE = 1 then
322         REMOTE_NODE := 2;
323      else
324         REMOTE_NODE := 1;
325      end if;
326
327      TEXT_IO.PUT_LINE( "About to go to sleep!" );
328      RTEMS.TASK_WAKE_AFTER( 1 * TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
329      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER" );
330      TEXT_IO.PUT_LINE( "Waking up!" );
331 
332      TEXT_IO.PUT( "Remote task's name is : " );
333      TEST_SUPPORT.PUT_NAME( MPTEST.EVENT_TASK_NAME( REMOTE_NODE ), TRUE );
334
335      TEXT_IO.PUT_LINE( "Getting TID of remote task" );
336
337      loop
338
339         RTEMS.TASK_IDENT(
340            MPTEST.EVENT_TASK_NAME( REMOTE_NODE ),
341            RTEMS.SEARCH_ALL_NODES,
342            REMOTE_TID,
343            STATUS
344         );
345
346         exit when RTEMS.IS_STATUS_SUCCESSFUL( STATUS );
347
348         TEXT_IO.PUT_LINE( "task_ident" );
349
350      end loop;
351
352      if MPTEST.MULTIPROCESSING_CONFIGURATION.NODE = 1 then
353         TEXT_IO.PUT_LINE( "Sending events to remote task" );
354
355         loop
356            exit when MPTEST.STOP_TEST = TRUE;
357
358            for COUNT in 1 .. MPTEST.EVENT_TASK_DOT_COUNT
359            loop
360               RTEMS.EVENT_SEND(
361                  REMOTE_TID,
362                  RTEMS.EVENT_16,
363                  STATUS
364               );
365               TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "EVENT_SEND" );
366
367               exit when MPTEST.STOP_TEST = TRUE;
368
369            end loop;
370
371            TEST_SUPPORT.PUT_DOT( "e" );
372 
373         end loop;
374
375      end if;
376         
377      TEXT_IO.PUT_LINE( "Receiving events from remote task" );
378
379      loop
380         exit when MPTEST.STOP_TEST = TRUE;
381
382         for COUNT in 1 .. MPTEST.EVENT_TASK_DOT_COUNT
383         loop
384            exit when MPTEST.STOP_TEST = TRUE;
385
386            RTEMS.EVENT_RECEIVE(
387               RTEMS.EVENT_16,
388               RTEMS.DEFAULT_OPTIONS,
389               RTEMS.NO_TIMEOUT,
390               EVENT_OUT,
391               STATUS
392            );   
393            TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "EVENT_RECEIVE" );
394
395         end loop;
396 
397         TEST_SUPPORT.PUT_DOT( "e" );
398 
399      end loop;
400
401      MPTEST.EXIT_TEST;
402 
403   end TEST_TASK;
404 
405--
406--  DELAYED_EVENTS_TASK
407--
408--  DESCRIPTION:
409--
410--  This is one of the test tasks.
411--
412 
413   procedure DELAYED_EVENTS_TASK ( 
414      ARGUMENT : in     RTEMS.TASK_ARGUMENT
415   ) is
416      COUNT         : RTEMS.UNSIGNED32;
417      PREVIOUS_MODE : RTEMS.MODE;
418      EVENTS_OUT    : RTEMS.EVENT_SET;
419      STATUS        : RTEMS.STATUS_CODES;
420   begin
421
422      RTEMS.TASK_MODE(
423         RTEMS.PREEMPT + RTEMS.TIMESLICE,
424         RTEMS.PREEMPT_MASK + RTEMS.TIMESLICE_MASK,
425         PREVIOUS_MODE,
426         STATUS
427      );
428      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_MODE" );
429 
430      RTEMS.TIMER_CREATE(
431         MPTEST.TIMER_NAME( 1 ),
432         MPTEST.TIMER_ID( 1 ),
433         STATUS
434      );
435      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TIMER_CREATE" );
436
437      RTEMS.TASK_IDENT(
438         RTEMS.SELF,
439         RTEMS.SEARCH_ALL_NODES,
440         MPTEST.TASK_ID( RTEMS.GET_INDEX( MPTEST.TIMER_ID( 1 ) ) ),
441         STATUS
442      );
443      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_IDENTS" );
444
445      loop
446
447         for COUNT in 1 .. MPTEST.DELAYED_EVENT_DOT_COUNT
448         loop
449            RTEMS.TIMER_FIRE_AFTER(
450               MPTEST.TIMER_ID( 1 ),
451               1,
452               MPTEST.DELAYED_SEND_EVENT'ACCESS,
453               RTEMS.NULL_ADDRESS,
454               STATUS
455            );
456            TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TIMER_FIRE_AFTER" );
457
458            RTEMS.EVENT_RECEIVE(
459               RTEMS.EVENT_16,
460               RTEMS.DEFAULT_OPTIONS,
461               RTEMS.NO_TIMEOUT,
462               EVENTS_OUT,
463               STATUS
464            );   
465            TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "EVENT_RECEIVE" );
466
467         end loop;
468 
469         TEST_SUPPORT.PUT_DOT( "." );
470 
471      end loop;
472 
473      MPTEST.EXIT_TEST;
474     
475   end DELAYED_EVENTS_TASK;
476 
477--
478--  MESSAGE_QUEUE_TASK
479--
480--  DESCRIPTION:
481--
482--  This is one of the test tasks.
483--
484 
485   procedure MESSAGE_QUEUE_TASK ( 
486      INDEX : in     RTEMS.TASK_ARGUMENT
487   ) is
488      COUNT          : RTEMS.UNSIGNED32;
489      YIELD_COUNT    : RTEMS.UNSIGNED32;
490      OVERFLOW_COUNT : RTEMS.UNSIGNED32_POINTER;
491      BUFFER_COUNT   : RTEMS.UNSIGNED32_POINTER;
492      STATUS         : RTEMS.STATUS_CODES;
493   begin
494
495      MPTEST.BUFFERS( INDEX ).FIELD1 := 0;
496      MPTEST.BUFFERS( INDEX ).FIELD2 := 0;
497      MPTEST.BUFFERS( INDEX ).FIELD3 := 0;
498      MPTEST.BUFFERS( INDEX ).FIELD4 := 0;
499
500      TEXT_IO.PUT_LINE( "Getting ID of message queue" );
501
502      loop
503
504         RTEMS.MESSAGE_QUEUE_IDENT(
505            MPTEST.QUEUE_NAME( 1 ),
506            RTEMS.SEARCH_ALL_NODES,
507            MPTEST.QUEUE_ID( 1 ),
508            STATUS
509         );
510         exit when RTEMS.IS_STATUS_SUCCESSFUL( STATUS );
511
512         TEXT_IO.PUT_LINE( "message_queue_ident FAILED!!" );
513
514      end loop;
515
516      if MPTEST.MULTIPROCESSING_CONFIGURATION.NODE = 1 then
517
518         RTEMS.MESSAGE_QUEUE_SEND(
519            MPTEST.QUEUE_ID( 1 ),
520            MPTEST.BUFFERS( INDEX ),
521            STATUS
522         );
523         TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "MESSAGE_QUEUE_SEND" );
524
525         OVERFLOW_COUNT := RTEMS.TO_UNSIGNED32_POINTER(
526                              MPTEST.BUFFERS( INDEX ).FIELD1'ADDRESS
527                           );
528               
529         BUFFER_COUNT := RTEMS.TO_UNSIGNED32_POINTER(
530                              MPTEST.BUFFERS( INDEX ).FIELD2'ADDRESS
531                           );
532               
533      else
534
535         OVERFLOW_COUNT := RTEMS.TO_UNSIGNED32_POINTER(
536                              MPTEST.BUFFERS( INDEX ).FIELD3'ADDRESS
537                           );
538               
539         BUFFER_COUNT := RTEMS.TO_UNSIGNED32_POINTER(
540                              MPTEST.BUFFERS( INDEX ).FIELD4'ADDRESS
541                           );
542
543      end if;
544
545      loop
546
547         exit when MPTEST.STOP_TEST = TRUE;
548
549         YIELD_COUNT := 100;
550
551         for COUNT in 1 .. MPTEST.MESSAGE_DOT_COUNT
552         loop
553
554           exit when MPTEST.STOP_TEST = TRUE;
555
556            RTEMS.MESSAGE_QUEUE_RECEIVE(
557               MPTEST.QUEUE_ID( 1 ),
558               MPTEST.BUFFERS( INDEX ),
559               RTEMS.DEFAULT_OPTIONS,
560               RTEMS.NO_TIMEOUT,
561               STATUS
562            );
563            TEST_SUPPORT.DIRECTIVE_FAILED(
564               STATUS,
565               "MESSAGE_QUEUE_RECEIVE"
566            );
567
568            if BUFFER_COUNT.ALL = RTEMS.UNSIGNED32'LAST then
569               BUFFER_COUNT.ALL   := 0;
570               OVERFLOW_COUNT.ALL := OVERFLOW_COUNT.ALL + 1;
571            else
572               BUFFER_COUNT.ALL := BUFFER_COUNT.ALL + 1;
573            end if;
574
575            RTEMS.MESSAGE_QUEUE_SEND(
576               MPTEST.QUEUE_ID( 1 ),
577               MPTEST.BUFFERS( INDEX ),
578               STATUS
579            );
580            TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "MESSAGE_QUEUE_SEND" );
581
582            if MPTEST.STOP_TEST = FALSE then
583               if MPTEST.MULTIPROCESSING_CONFIGURATION.NODE = 1 then
584
585                  YIELD_COUNT := YIELD_COUNT - 1;
586
587                  if YIELD_COUNT = 0 then
588
589                     RTEMS.TASK_WAKE_AFTER( RTEMS.YIELD_PROCESSOR, STATUS );
590                     TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "YIELD" );
591
592                     YIELD_COUNT := 100;
593
594                  end if;
595
596               end if;
597
598            end if;
599         
600         end loop;
601
602         TEST_SUPPORT.PUT_DOT( "m" );
603
604      end loop;
605
606      MPTEST.EXIT_TEST;
607
608   end MESSAGE_QUEUE_TASK;
609 
610--
611--  PARTITION_TASK
612--
613--  DESCRIPTION:
614--
615--  This is one of the test tasks.
616--
617 
618   procedure PARTITION_TASK ( 
619      IGNORED : in     RTEMS.TASK_ARGUMENT
620   ) is
621      COUNT  : RTEMS.UNSIGNED32;
622      BUFFER : RTEMS.ADDRESS;
623      STATUS : RTEMS.STATUS_CODES;
624   begin
625
626      TEXT_IO.PUT_LINE( "Getting ID of partition" );
627 
628      loop
629
630         RTEMS.PARTITION_IDENT(
631            MPTEST.PARTITION_NAME( 1 ),
632            RTEMS.SEARCH_ALL_NODES,
633            MPTEST.PARTITION_ID( 1 ),
634            STATUS
635         );
636         exit when RTEMS.IS_STATUS_SUCCESSFUL( STATUS );
637
638         TEXT_IO.PUT_LINE( "partition_ident FAILED!!" );
639
640      end loop;
641
642      loop
643
644         exit when MPTEST.STOP_TEST = TRUE;
645
646         for COUNT in 1 .. MPTEST.PARTITION_DOT_COUNT
647         loop
648
649            exit when MPTEST.STOP_TEST = TRUE;
650
651            RTEMS.PARTITION_GET_BUFFER(
652               MPTEST.PARTITION_ID( 1 ),
653               BUFFER,
654               STATUS
655            );
656            TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "PARTITION_GET_BUFFER" );
657
658            RTEMS.PARTITION_RETURN_BUFFER(
659               MPTEST.PARTITION_ID( 1 ),
660               BUFFER,
661               STATUS
662            );
663            TEST_SUPPORT.DIRECTIVE_FAILED(
664               STATUS,
665               "PARTITION_RETURN_BUFFER"
666            );
667
668            if MPTEST.MULTIPROCESSING_CONFIGURATION.NODE = 1 then
669
670               RTEMS.TASK_WAKE_AFTER( RTEMS.YIELD_PROCESSOR, STATUS );
671               TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "YIELD" );
672
673            end if;
674
675         end loop;
676
677         TEST_SUPPORT.PUT_DOT( "p" );
678
679      end loop;
680
681      MPTEST.EXIT_TEST;
682
683   end PARTITION_TASK;
684 
685--
686--  SEMAPHORE_TASK
687--
688--  DESCRIPTION:
689--
690--  This is one of the test tasks.
691--
692 
693   procedure SEMAPHORE_TASK ( 
694      ARGUMENT : in     RTEMS.TASK_ARGUMENT
695   ) is
696      COUNT          : RTEMS.UNSIGNED32;
697      YIELD_COUNT    : RTEMS.UNSIGNED32;
698      STATUS         : RTEMS.STATUS_CODES;
699   begin
700
701      TEXT_IO.PUT_LINE( "Getting ID of semaphore" );
702
703      loop
704
705         RTEMS.SEMAPHORE_IDENT(
706            MPTEST.SEMAPHORE_NAME( 1 ),
707            RTEMS.SEARCH_ALL_NODES,
708            MPTEST.SEMAPHORE_ID( 1 ),
709            STATUS
710         );
711         exit when RTEMS.IS_STATUS_SUCCESSFUL( STATUS );
712
713         TEXT_IO.PUT_LINE( "semaphore_ident FAILED!!" );
714
715      end loop;
716
717      loop
718
719         YIELD_COUNT := 100;
720
721         exit when MPTEST.STOP_TEST = TRUE;
722
723         for COUNT in 1 .. MPTEST.SEMAPHORE_DOT_COUNT
724         loop
725
726            exit when MPTEST.STOP_TEST = TRUE;
727
728            RTEMS.SEMAPHORE_OBTAIN(
729               MPTEST.SEMAPHORE_ID( 1 ),
730               RTEMS.DEFAULT_OPTIONS,
731               RTEMS.NO_TIMEOUT,
732               STATUS
733            );
734            TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN" );
735
736            RTEMS.SEMAPHORE_RELEASE( MPTEST.SEMAPHORE_ID( 1 ), STATUS );
737            TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_RELEASE" );
738
739            if MPTEST.MULTIPROCESSING_CONFIGURATION.NODE = 1 then
740
741               YIELD_COUNT := YIELD_COUNT - 1;
742
743               if YIELD_COUNT = 0 then
744
745                  RTEMS.TASK_WAKE_AFTER( RTEMS.YIELD_PROCESSOR, STATUS );
746                  TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "YIELD" );
747
748                  YIELD_COUNT := 100;
749
750               end if;
751
752            end if;
753         
754         end loop;
755
756         TEST_SUPPORT.PUT_DOT( "s" );
757
758      end loop;
759
760      MPTEST.EXIT_TEST;
761
762   end SEMAPHORE_TASK;
763 
764end MPTEST;
Note: See TracBrowser for help on using the repository browser.