source: rtems/testsuites/sptests/spsize/size.c

Last change on this file was d865c65, checked in by Joel Sherrill <joel@…>, on 03/31/22 at 21:36:45

testsuites/sptests/sp[s-z]*: Change license to BSD-2

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