source: rtems/testsuites/sptests/spsize/size.c @ 715d616

Last change on this file since 715d616 was 146adb1, checked in by Sebastian Huber <sebastian.huber@…>, on Jul 17, 2017 at 5:30:46 AM

sparc: Add lazy floating point switch

The SPARC ABI is a bit special with respect to the floating point context.
The complete floating point context is volatile. Thus, from an ABI point
of view nothing needs to be saved and restored during a context switch.
Instead the floating point context must be saved and restored during
interrupt processing. Historically, the deferred floating point switch was
used for SPARC and the complete floating point context is saved and
restored during a context switch to the new floating point unit owner.
This is a bit dangerous since post-switch actions (e.g. signal handlers)
and context switch extensions may silently corrupt the floating point
context.

The floating point unit is disabled for interrupt handlers. Thus, in case
an interrupt handler uses the floating point unit then this will result in a
trap (INTERNAL_ERROR_ILLEGAL_USE_OF_FLOATING_POINT_UNIT).

In uniprocessor configurations, a lazy floating point context switch is
used. In case an active floating point thread is interrupted (PSR[EF] == 1)
and a thread dispatch is carried out, then this thread is registered as the
floating point owner. When a floating point owner is present during a
context switch, the floating point unit is disabled for the heir thread
(PSR[EF] == 0). The floating point disabled trap checks that the use of the
floating point unit is allowed and saves/restores the floating point context
on demand.

Update #3077.

  • Property mode set to 100644
File size: 19.8 KB
Line 
1/**
2 *  @file
3 *
4 *  This program is run to determine the data space and work space
5 *  requirements of the current version of RTEMS.
6 */
7
8/*
9 *  COPYRIGHT (c) 1989-2014.
10 *  On-Line Applications Research Corporation (OAR).
11 *
12 *  The license and distribution terms for this file may be
13 *  found in the file LICENSE in this distribution or at
14 *  http://www.rtems.org/license/LICENSE.
15 */
16
17#ifdef HAVE_CONFIG_H
18#include "config.h"
19#endif
20
21#include <rtems/system.h>
22#include <rtems/config.h>
23#include <rtems/score/copyrt.h>
24#include <rtems/rtems/clock.h>
25#include <rtems/rtems/tasksimpl.h>
26#include <rtems/rtems/dpmemimpl.h>
27#include <rtems/rtems/eventimpl.h>
28#include <rtems/extensionimpl.h>
29#include <rtems/fatal.h>
30#include <rtems/init.h>
31#include <rtems/score/isr.h>
32#include <rtems/rtems/intr.h>
33#include <rtems/io.h>
34#include <rtems/rtems/messageimpl.h>
35#if defined(RTEMS_MULTIPROCESSING)
36#include <rtems/rtems/mp.h>
37#include <rtems/score/mpciimpl.h>
38#endif
39#include <rtems/rtems/partimpl.h>
40#include <rtems/score/priority.h>
41#include <rtems/rtems/ratemonimpl.h>
42#include <rtems/rtems/regionimpl.h>
43#include <rtems/rtems/semimpl.h>
44#include <rtems/rtems/signal.h>
45#include <rtems/score/scheduler.h>
46#include <rtems/score/sysstate.h>
47#include <rtems/score/thread.h>
48#include <rtems/rtems/timerimpl.h>
49#include <rtems/score/todimpl.h>
50#include <rtems/score/userextimpl.h>
51#include <rtems/score/watchdogimpl.h>
52#include <rtems/score/wkspace.h>
53#if defined(RTEMS_SMP)
54  #include <rtems/score/smp.h>
55#endif
56
57#include <stdlib.h>
58#include <stdio.h>
59#include <unistd.h>
60#include <tmacros.h>
61
62#include "system.h"
63
64/* external function prototypes */
65int getint( void );
66void size_rtems(int mode);
67void help_size(void);
68void print_formula(void);
69
70
71/* These are always defined by the executive.
72 *
73 * #include <rtems/copyrt.h>
74 * #include <rtems/tables.h>
75 */
76#define  HEAP_OVHD        16    /* wasted heap space per task stack */
77#define  NAME_PTR_SIZE     8    /* size of name and pointer table entries */
78
79/*
80 *  This assumes the default Priority Scheduler
81 */
82#include <rtems/score/prioritybitmapimpl.h>
83#include <rtems/score/schedulerpriority.h>
84
85/* Priority scheduling per-thread consumption. Gets
86 * included in the PER_TASK consumption.
87 */
88#define SCHEDULER_TASK_WKSP     (sizeof(Scheduler_priority_Node))
89
90/* Priority scheduling workspace consumption
91 *
92 * Include allocation of ready queue.
93 */
94#define SCHEDULER_WKSP_SIZE  \
95    (sizeof(Scheduler_priority_Context) + \
96     RTEMS_MAXIMUM_PRIORITY * sizeof(Chain_Control ))
97/****** END OF MEMORY USAGE OF DEFAULT PRIORITY SCHEDULER ******/
98
99#define PER_TASK      \
100     (long) (sizeof (Thread_Control) + \
101      NAME_PTR_SIZE + HEAP_OVHD + sizeof( RTEMS_API_Control ) + \
102      SCHEDULER_TASK_WKSP )
103#define PER_SEMAPHORE \
104     (long) (sizeof (Semaphore_Control) + NAME_PTR_SIZE)
105#define PER_TIMER     \
106     (long) (sizeof (Timer_Control) + NAME_PTR_SIZE)
107#define PER_MSGQ      \
108     (long) (sizeof (Message_queue_Control) + NAME_PTR_SIZE)
109#define PER_REGN      \
110     (long) (sizeof (Region_Control) + NAME_PTR_SIZE)
111#define PER_PART      \
112     (long) (sizeof (Partition_Control) + NAME_PTR_SIZE)
113#define PER_PERIOD      \
114     (long) (sizeof (Rate_monotonic_Control) + NAME_PTR_SIZE)
115#define PER_PORT      \
116     (long) (sizeof (Dual_ported_memory_Control) + NAME_PTR_SIZE)
117#define PER_EXTENSION     \
118     (long) (sizeof (Extension_Control) + NAME_PTR_SIZE)
119
120#define PER_DRV       (long) (0)
121#define PER_FPTASK    (long) (CONTEXT_FP_SIZE)
122#define PER_GOBTBL    (long) (sizeof (Chain_Control)*4)
123#define PER_NODE      (long) PER_GOBTBL
124#if defined(RTEMS_MULTIPROCESSING)
125#define PER_GOBJECT   (long) (sizeof (Objects_MP_Control))
126#else
127#define PER_GOBJECT   (long) 0
128#endif
129#define PER_PROXY     (long) (sizeof (Thread_Proxy_control))
130
131#if !defined(RTEMS_MULTIPROCESSING) || (CPU_ALL_TASKS_ARE_FP != TRUE)
132#define MPCI_RECEIVE_SERVER_FP (long) 0
133#else
134#define MPCI_RECEIVE_SERVER_FP (long) (sizeof( Context_Control_fp ))
135#endif
136
137#if (CPU_IDLE_TASK_IS_FP == TRUE)
138#define SYSTEM_IDLE_FP (long) (sizeof( Context_Control_fp ))
139#else
140#define SYSTEM_IDLE_FP (long) 0
141#endif
142
143#if !defined(RTEMS_MULTIPROCESSING)
144#define MPCI_RECEIVE_SERVER_STACK_SIZE 0
145#endif
146
147#if defined(RTEMS_MULTIPROCESSING)
148#define MPCI_RECEIVE_SERVER_STACK_SIZE \
149
150#define MP_SYSTEM_TASKS \
151   (STACK_MINIMUM_SIZE + CPU_MPCI_RECEIVE_SERVER_EXTRA_STACK + \
152    sizeof(Thread_Control) + \
153    MPCI_RECEIVE_SERVER_FP)
154
155extern CORE_semaphore_Control _MPCI_Semaphore;
156#else
157#define MP_SYSTEM_TASKS 0
158#endif
159
160/*
161 *  Idle and the MPCI Receive Server Threads
162 */
163
164#define SYSTEM_TASKS  \
165    (STACK_MINIMUM_SIZE + sizeof(Thread_Control) + SYSTEM_IDLE_FP + \
166     MP_SYSTEM_TASKS)
167
168/* FIXME: uint32_t doesn't seem right */
169uint32_t   sys_req;
170
171void size_rtems(
172  int mode
173)
174{
175int uninitialized = 0;
176int initialized = 0;
177
178/*
179 *  The following data is allocated for each Manager:
180 *
181 *    + Per Manager Object Information
182 *      - local pointer table
183 *      - local name table
184 *      - the object's control blocks
185 *      - global name chains
186 *
187 *  The following is the data allocate from the RTEMS Workspace Area.
188 *  The order indicates the order in which RTEMS allocates it.
189 *
190 *    + Object MP
191 *      - Global Object CB's
192 *    + Thread MP
193 *      - Proxies Chain
194 *    + Scheduler
195 *      - Ready queue
196 *    + Interrupt Manager
197 *      - Interrupt Stack
198 *    + Timer Manager
199 *      - per Manager Object Data
200 *    + Extension Manager
201 *      - per Manager Object Data
202 *    + Message Queue Manager
203 *      - per Manager Object Data
204 *      - Message Buffers
205 *    + Semaphore Manager
206 *      - per Manager Object Data
207 *    + Partition Manager
208 *      - per Manager Object Data
209 *    + Region Manager
210 *      - per Manager Object Data
211 *    + Dual Ported Memory Manager
212 *      - per Manager Object Data
213 *    + Rate Monotonic Manager
214 *      - per Manager Object Data
215 *    + Internal Threads Handler
216 *      - MPCI Receive Server Thread TCB
217 *      - IDLE Thread TCB
218 *      - MPCI Receive Server Thread stack
219 *      - MPCI Receive Server Thread FP area (if CPU requires this)
220 *      - IDLE Thread stack
221 *      - IDLE Thread FP area (if CPU requires this)
222 *
223 *  This does not take into account any CPU dependent alignment requirements.
224 *
225 *  The following calculates the overhead needed by RTEMS from the
226 *  Workspace Area.
227 */
228sys_req = SYSTEM_TASKS        +     /* MPCI Receive Server and IDLE */
229          NAME_PTR_SIZE       +     /* Task Overhead */
230          SCHEDULER_WKSP_SIZE +     /* Scheduler Overhead */
231          NAME_PTR_SIZE       +     /* Timer Overhead */
232          NAME_PTR_SIZE       +     /* Semaphore Overhead */
233          NAME_PTR_SIZE       +     /* Message Queue Overhead */
234          NAME_PTR_SIZE       +     /* Region Overhead */
235          NAME_PTR_SIZE       +     /* Partition Overhead */
236          NAME_PTR_SIZE       +     /* Dual-Ported Memory Overhead */
237          NAME_PTR_SIZE       +     /* Rate Monotonic Overhead */
238          NAME_PTR_SIZE       +     /* Extension Overhead */
239          PER_NODE;                 /* Extra Gobject Table */
240
241uninitialized =
242/*address.h*/   0                                         +
243
244/*asr.h*/       0                                         +
245
246/*attr.h*/      0                                         +
247
248/*bitfield.h*/  0                                         +
249
250/*chain.h*/     0                                         +
251
252/*clock.h*/     0                                         +
253
254/*config.h*/
255        #if defined(RTEMS_MULTIPROCESSING)
256                (sizeof _Configuration_MP_table)          +
257        #endif
258
259/*context.h*/   (sizeof _Thread_Dispatch_necessary)        +
260
261/*copyrt.h*/    0                                         +
262
263/*dpmemimpl.h*/ (sizeof _Dual_ported_memory_Information)  +
264
265#if defined(RTEMS_MULTIPROCESSING)
266/*eventmp.h*/   0                                         +
267#endif
268
269/*extensionimpl.h*/ (sizeof _Extension_Information)       +
270
271/*fatal.h*/     0                                         +
272
273/*heap.h*/      0                                         +
274
275/*init.h*/      0                                         +
276
277/*interr.h*/    (sizeof _Internal_errors_What_happened)   +
278
279/*intr.h*/      0                                         +
280
281/*isr.h*/       (sizeof _ISR_Nest_level)                  +
282#if (CPU_SIMPLE_VECTORED_INTERRUPTS == TRUE)
283                (sizeof _ISR_Vector_table)                +
284#endif
285
286/*messageimpl.h*/ (sizeof _Message_queue_Information)     +
287
288/*modes.h*/     0                                         +
289
290#if defined(RTEMS_MULTIPROCESSING)
291/*mp.h*/        0                                         +
292#endif
293
294#if defined(RTEMS_MULTIPROCESSING)
295/*mpciimpl.h*/  (sizeof _MPCI_Remote_blocked_threads)     +
296                (sizeof _MPCI_Semaphore)                  +
297                (sizeof _MPCI_table)                      +
298                (sizeof _MPCI_Receive_server_tcb)         +
299                (sizeof _MPCI_Packet_processors)          +
300#endif
301
302#if defined(RTEMS_MULTIPROCESSING)
303/*mppkt.h*/     0                                         +
304#endif
305
306#if defined(RTEMS_MULTIPROCESSING)
307/*mptables.h*/  0                                         +
308#endif
309
310#if defined(RTEMS_MULTIPROCESSING)
311/*msgmp.h*/     0                                         +
312#endif
313
314/*object.h*/    (sizeof _Objects_Local_node)              +
315                (sizeof _Objects_Maximum_nodes)           +
316                (sizeof _Objects_Information_table)       +
317
318/*options.h*/   0                                         +
319
320/*partimpl.h*/  (sizeof _Partition_Information)           +
321
322#if defined(RTEMS_MULTIPROCESSING)
323/*partmp.h*/    0                                         +
324#endif
325
326/*percpu.h*/    (_SMP_Get_processor_count() * sizeof(Per_CPU_Control))  +
327
328/*ratemonimpl.h*/ (sizeof _Rate_monotonic_Information)    +
329
330/*regionimpl.h*/ (sizeof _Region_Information)             +
331
332#if defined(RTEMS_MULTIPROCESSING)
333/*regionmp.h*/  0                                         +
334#endif
335
336/*rtems.h*/     /* Not applicable */
337
338/*semimpl.h*/   (sizeof _Semaphore_Information)           +
339
340#if defined(RTEMS_MULTIPROCESSING)
341/*semmp.h*/     0                                         +
342#endif
343
344/*signal.h*/    0                                         +
345
346/*signalmp.h*/  0                                         +
347
348/*stack.h*/     0                                         +
349
350/*states.h*/    0                                         +
351
352/*status.h*/    0                                         +
353
354/*sysstate.h*/  (sizeof _System_state_Current)            +
355#if defined(RTEMS_MULTIPROCESSING)
356                (sizeof _System_state_Is_multiprocessing) +
357#endif
358
359#if defined(RTEMS_MULTIPROCESSING)
360/*taskmp.h*/    0                                         +
361#endif
362
363/*tasksimpl.h*/ (sizeof _RTEMS_tasks_Information)         +
364
365/*thread.h*/    (sizeof _Thread_Dispatch_disable_level)   +
366                (sizeof _Thread_Executing)                +
367                (sizeof _Thread_Heir)                     +
368#if (CPU_HARDWARE_FP == 1) || (CPU_SOFTWARE_FP == 1)
369                (sizeof _Thread_Allocated_fp)             +
370#endif
371                (sizeof _Thread_Internal_information)     +
372
373/*threadq.h*/
374
375/*timerimpl.h*/ (sizeof _Timer_Information)               +
376
377/*tqdata.h*/    0                                         +
378
379/*types.h*/     0                                         +
380
381/*userext.h*/   (sizeof _User_extensions_List)            +
382
383/*watchdog.h*/  (sizeof _Watchdog_Ticks_since_boot)       +
384
385/*wkspace.h*/   (sizeof _Workspace_Area);
386
387#ifndef unix  /* make sure this is not a native compile */
388
389#ifdef __i386__
390
391/* cpu.h */
392uninitialized += (sizeof _CPU_Null_fp_context);
393
394#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
395uninitialized += (sizeof _CPU_Interrupt_stack_low) +
396                 (sizeof _CPU_Interrupt_stack_high);
397#endif
398
399#endif
400
401#ifdef __mc68000__
402
403/* cpu.h */
404uninitialized += (sizeof _CPU_Interrupt_stack_low) +
405                 (sizeof _CPU_Interrupt_stack_high);
406
407#endif
408
409#ifdef __sparc__
410
411/* cpu.h */
412uninitialized += (sizeof _CPU_Interrupt_stack_low) +
413                 (sizeof _CPU_Interrupt_stack_high);
414
415#endif
416
417
418#ifdef no_cpu
419
420/* cpu.h */
421uninitialized += (sizeof _CPU_Null_fp_context) +
422                 (sizeof _CPU_Interrupt_stack_low) +
423                 (sizeof _CPU_Interrupt_stack_high) +
424                 (sizeof _CPU_Thread_dispatch_pointer);
425
426#endif
427
428#ifdef __PPC__
429
430/* cpu.h */
431uninitialized += (sizeof _CPU_Interrupt_stack_low) +
432                 (sizeof _CPU_Interrupt_stack_high);
433
434#endif
435#endif /* !unix */
436
437initialized +=
438/*copyrt.h*/    (strlen(_Copyright_Notice)+1)             +
439
440#if defined(RTEMS_MULTIPROCESSING)
441                (sizeof _Initialization_Default_multiprocessing_table)  +
442#endif
443                (strlen(_RTEMS_version)+1);
444
445
446
447#ifndef unix /* make sure this is not native */
448#ifdef __sparc__
449
450initialized +=  (sizeof _CPU_Trap_slot_template);
451
452#endif
453#endif /* !unix */
454
455puts( "" );
456
457  if ( mode == 0 ) help_size();
458  else             print_formula();
459
460printf( "\n" );
461printf( "RTEMS uninitialized data consumes %d bytes\n", uninitialized );
462printf( "RTEMS initialized data consumes %d bytes\n", initialized );
463
464}
465
466void help_size()
467{
468int c = '\0';
469int break_loop;
470int total_size;
471int task_stacks;
472int interrupt_stack;
473int maximum_tasks, size_tasks;
474int maximum_sems, size_sems;
475int maximum_timers, size_timers;
476int maximum_msgqs, size_msgqs;
477int maximum_msgs, size_msgs_overhead;
478int maximum_regns, size_regns;
479int maximum_parts, size_parts;
480int maximum_ports, size_ports;
481int maximum_periods, size_periods;
482int maximum_extensions, size_extensions;
483int maximum_drvs, size_drvs;
484int maximum_fps, size_fps;
485int maximum_nodes, size_nodes;
486int maximum_gobjs, size_gobjs;
487int maximum_proxies, size_proxies;
488
489total_size = sys_req;    /* Fixed Overhead */
490printf( "What is maximum_tasks? " );
491maximum_tasks = getint();
492size_tasks = PER_TASK * maximum_tasks;
493total_size += size_tasks;
494
495printf( "What is maximum_semaphores? " );
496maximum_sems = getint();
497size_sems = PER_SEMAPHORE * maximum_sems;
498total_size += size_sems;
499
500printf( "What is maximum_timers? " );
501maximum_timers = getint();
502size_timers = PER_TIMER * maximum_timers;
503total_size += size_timers;
504
505printf( "What is maximum_message_queues? " );
506maximum_msgqs = getint();
507size_msgqs = PER_MSGQ * maximum_msgqs;
508total_size += size_msgqs;
509
510printf( "What is maximum_messages?  XXXX " );
511maximum_msgs = getint();
512size_msgs_overhead = 0;
513total_size += size_msgs_overhead;
514
515printf( "What is maximum_regions? " );
516maximum_regns = getint();
517size_regns = PER_REGN * maximum_regns;
518total_size += size_regns;
519
520printf( "What is maximum_partitions? " );
521maximum_parts = getint();
522size_parts = PER_PART * maximum_parts;
523total_size += size_parts;
524
525printf( "What is maximum_ports? " );
526maximum_ports = getint();
527size_ports = PER_PORT * maximum_ports;
528total_size += size_ports;
529
530printf( "What is maximum_periods? " );
531maximum_periods = getint();
532size_periods = PER_PERIOD * maximum_periods;
533total_size += size_periods;
534
535printf( "What is maximum_extensions? " );
536maximum_extensions = getint();
537size_extensions = PER_EXTENSION * maximum_extensions;
538total_size += size_extensions;
539
540printf( "What is number_of_device_drivers? " );
541maximum_drvs = getint();
542size_drvs = PER_DRV  * maximum_drvs;
543total_size += size_drvs;
544
545printf( "What will be total stack requirement for all tasks? " );
546task_stacks = getint();
547total_size += task_stacks;
548
549printf( "What is the size of the interrupt stack? " );
550interrupt_stack = getint();
551total_size += interrupt_stack;
552
553printf( "How many tasks will be created with the FP flag? " );
554maximum_fps = getint();
555size_fps = PER_FPTASK  * maximum_fps;
556total_size += size_fps;
557
558printf( "Is this a single processor system? " );
559for ( break_loop=0 ; !break_loop; c = getchar() ) {
560  switch ( c ) {
561    case 'Y':  case 'y':
562    case 'N':  case 'n':
563      break_loop = 1;
564      break;
565  }
566}
567printf( "%c\n", c );
568if ( c == 'n' || c == 'N' ) {
569  printf( "What is maximum_nodes? " );
570  maximum_nodes = getint();
571  size_nodes = PER_NODE * maximum_nodes;
572  total_size += size_nodes;
573  printf( "What is maximum_global_objects? " );
574  maximum_gobjs = getint();
575  size_gobjs = PER_GOBJECT * maximum_gobjs;
576  total_size += size_gobjs;
577  printf( "What is maximum_proxies? " );
578  maximum_proxies = getint();
579  size_proxies = PER_PROXY * maximum_proxies;
580  total_size += size_proxies;
581} else {
582  maximum_nodes = 0;
583  size_nodes = PER_NODE * 0;
584  maximum_gobjs = 0;
585  size_gobjs = PER_GOBJECT * 0;
586  maximum_proxies = 0;
587  size_proxies = PER_PROXY * 0;
588}
589
590printf( "\n\n" );
591printf( " ************** EXECUTIVE WORK SPACE REQUIRED **************\n" );
592printf( " Tasks                - %03d * %03ld            =  %ld\n",
593          maximum_tasks, PER_TASK, (long) size_tasks );
594printf( " Semaphores           - %03d * %03ld            =  %ld\n",
595          maximum_sems, PER_SEMAPHORE, (long) size_sems );
596printf( " Timers               - %03d * %03ld            =  %ld\n",
597          maximum_timers, PER_TIMER, (long) size_timers );
598printf( " Msg Queues           - %03d * %03ld            =  %ld\n",
599          maximum_msgqs, PER_MSGQ, (long) size_msgqs );
600printf( " Messages Overhead    - %03d * %03d            =  %ld\n",
601          maximum_msgs, 0 /* PER_MSG_OVERHEAD */, (long) size_msgs_overhead );
602printf( " Regions              - %03d * %03ld            =  %ld\n",
603          maximum_regns, PER_REGN, (long) size_regns);
604printf( " Partitions           - %03d * %03ld            =  %ld\n",
605          maximum_parts, PER_PART, (long) size_parts );
606printf( " Periods              - %03d * %03ld            =  %ld\n",
607          maximum_periods, PER_PERIOD, (long) size_periods );
608printf( " Extensions           - %03d * %03ld            =  %ld\n",
609          maximum_extensions, PER_EXTENSION, (long) size_extensions );
610printf( " Device Drivers       - %03d * %03ld            =  %ld\n",
611          maximum_drvs, PER_DRV, (long) size_drvs );
612
613printf( " System Requirements  - %04" PRIu32 "                 =  %"PRIu32 "\n",
614          sys_req, sys_req );
615
616printf( " Floating Point Tasks - %03d * %03ld            =  %ld\n",
617          maximum_fps, PER_FPTASK, (long) size_fps );
618printf( " Application Task Stacks -                     =  %d\n",
619          task_stacks );
620printf( " Interrupt Stacks -                            =  %d\n",
621          task_stacks );
622printf( " \n" );
623printf( " Global object tables - %03d * %03ld            =  %ld\n",
624          maximum_nodes, PER_NODE, (long) size_nodes );
625printf( " Global objects       - %03d * %03ld            =  %ld\n",
626          maximum_gobjs, PER_GOBJECT, (long) size_gobjs );
627printf( " Proxies              - %03d * %03ld            =  %ld\n",
628          maximum_proxies, PER_PROXY, (long) size_proxies );
629printf( "\n\n" );
630printf( " TOTAL                                       = %d bytes\n",
631      total_size );
632}
633
634void print_formula()
635{
636printf( " ************** EXECUTIVE WORK SPACE FORMULA **************\n" );
637printf( " Tasks                - maximum_tasks * %ld\n",      PER_TASK );
638printf( " Timers               - maximum_timers * %ld\n",     PER_TIMER );
639printf( " Semaphores           - maximum_semaphores * %ld\n", PER_SEMAPHORE);
640printf( " Message Queues       - maximum_message_queues * %ld\n", PER_MSGQ );
641printf( " Messages             -\n");
642printf( " Regions              - maximum_regions * %ld\n",    PER_REGN );
643printf( " Partitions           - maximum_partitions * %ld\n", PER_PART );
644printf( " Ports                - maximum_ports * %ld\n",      PER_PORT );
645printf( " Periods              - maximum_periods * %ld\n",    PER_PORT );
646printf( " Extensions           - maximum_extensions * %ld\n", PER_EXTENSION );
647printf( " Device Drivers       - number_of_device_drivers * %ld\n", PER_DRV);
648printf( " System Requirements  - %" PRIu32 "\n",              sys_req );
649printf( " Floating Point Tasks - FPMASK Tasks * %ld\n",       PER_FPTASK );
650printf( " User's Tasks' Stacks -\n" );
651printf( " Interrupt Stack      -\n" );
652printf( " \n" );
653printf( " Global object tables - maximum_nodes * %ld\n",          PER_NODE );
654printf( " Global objects       - maximum_global_objects * %ld\n", PER_GOBJECT );
655printf( " Proxies              - maximum_proxies * %ld\n",        PER_PROXY );
656}
Note: See TracBrowser for help on using the repository browser.