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

4.104.114.84.95
Last change on this file since cd3fb80 was 97e2729d, checked in by Joel Sherrill <joel.sherrill@…>, on 11/23/98 at 17:38:09

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