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

4.104.11
Last change on this file since b84f1fdc was b84f1fdc, checked in by Joel Sherrill <joel.sherrill@…>, on May 10, 2009 at 2:39:46 PM

2009-05-10 Joel Sherrill <joel.sherrill@…>

  • sp04/system.h, sp04/task1.c, sp04/tswitch.c, sp07/init.c, sp12/init.c, sp13/putbuff.c, sp13/system.h, sp13/task1.c, sp15/init.c, sp16/system.h, sp19/fptask.c, sp25/system.h, sp26/task1.c, sp27/init.c, sp28/init.c, sp29/init.c, sp31/task1.c, sp33/init.c, sp34/changepri.c, sp35/priinv.c, sp37/init.c, sp38/init.c, sp39/init.c, sp41/init.c, sp42/init.c, sp43/init.c, sp44/init.c, sp45/init.c, sp46/init.c, sp47/init.c, sp48/init.c, spfatal03/testcase.h, spfatal05/testcase.h, spfatal06/testcase.h, spfatal_support/system.h, spobjgetnext/init.c, spsize/getint.c, spsize/size.c: Fix warnings.
  • Property mode set to 100644
File size: 20.6 KB
Line 
1/*
2 *  This program is run to determine the data space and work space
3 *  requirements of the current version of RTEMS.
4 *
5 *  COPYRIGHT (c) 1989-2009.
6 *  On-Line Applications Research Corporation (OAR).
7 *
8 *  The license and distribution terms for this file may be
9 *  found in the file LICENSE in this distribution or at
10 *  http://www.rtems.com/license/LICENSE.
11 *
12 *  $Id$
13 */
14
15#include <rtems/system.h>
16#include <rtems/config.h>
17#include <rtems/score/apiext.h>
18#include <rtems/score/copyrt.h>
19#include <rtems/rtems/clock.h>
20#include <rtems/rtems/tasks.h>
21#include <rtems/rtems/dpmem.h>
22#include <rtems/rtems/event.h>
23#include <rtems/extension.h>
24#include <rtems/fatal.h>
25#include <rtems/init.h>
26#include <rtems/score/isr.h>
27#include <rtems/rtems/intr.h>
28#include <rtems/io.h>
29#include <rtems/rtems/message.h>
30#if defined(RTEMS_MULTIPROCESSING)
31#include <rtems/rtems/mp.h>
32#include <rtems/score/mpci.h>
33#endif
34#include <rtems/rtems/part.h>
35#include <rtems/score/priority.h>
36#include <rtems/rtems/ratemon.h>
37#include <rtems/rtems/region.h>
38#include <rtems/rtems/sem.h>
39#include <rtems/rtems/signal.h>
40#include <rtems/score/sysstate.h>
41#include <rtems/score/thread.h>
42#include <rtems/rtems/timer.h>
43#include <rtems/score/tod.h>
44#include <rtems/score/userext.h>
45#include <rtems/score/wkspace.h>
46
47#include <stdlib.h>
48#include <stdio.h>
49#include <unistd.h>
50#include <tmacros.h>
51
52/* external function prototypes */
53int getint( void );
54void size_rtems(int mode);
55void help_size(void);
56void print_formula(void);
57
58
59/* These are always defined by the executive.
60 *
61 * #include <rtems/copyrt.h>
62 * #include <rtems/tables.h>
63 * #include <rtems/sptables.h>
64 */
65#define  HEAP_OVHD        16    /* wasted heap space per task stack */
66#define  NAME_PTR_SIZE     8    /* size of name and pointer table entries */
67#define  READYCHAINS_SIZE  \
68    ((RTEMS_MAXIMUM_PRIORITY + 1) * sizeof(Chain_Control ))
69
70#define PER_TASK      \
71     (long) (sizeof (Thread_Control) + \
72      NAME_PTR_SIZE + HEAP_OVHD + sizeof( RTEMS_API_Control ))
73#define PER_SEMAPHORE \
74     (long) (sizeof (Semaphore_Control) + NAME_PTR_SIZE)
75#define PER_TIMER     \
76     (long) (sizeof (Timer_Control) + NAME_PTR_SIZE)
77#define PER_MSGQ      \
78     (long) (sizeof (Message_queue_Control) + NAME_PTR_SIZE)
79#define PER_REGN      \
80     (long) (sizeof (Region_Control) + NAME_PTR_SIZE)
81#define PER_PART      \
82     (long) (sizeof (Partition_Control) + NAME_PTR_SIZE)
83#define PER_PERIOD      \
84     (long) (sizeof (Rate_monotonic_Control) + NAME_PTR_SIZE)
85#define PER_PORT      \
86     (long) (sizeof (Dual_ported_memory_Control) + NAME_PTR_SIZE)
87#define PER_EXTENSION     \
88     (long) (sizeof (Extension_Control) + NAME_PTR_SIZE)
89
90#define PER_DRV       (long) (0)
91#define PER_FPTASK    (long) (CONTEXT_FP_SIZE)
92#define PER_GOBTBL    (long) (sizeof (Chain_Control)*4)
93#define PER_NODE      (long) PER_GOBTBL
94#if defined(RTEMS_MULTIPROCESSING)
95#define PER_GOBJECT   (long) (sizeof (Objects_MP_Control))
96#else
97#define PER_GOBJECT   (long) 0
98#endif
99#define PER_PROXY     (long) (sizeof (Thread_Proxy_control))
100
101#if !defined(RTEMS_MULTIPROCESSING) || (CPU_ALL_TASKS_ARE_FP != TRUE)
102#define MPCI_RECEIVE_SERVER_FP (long) 0
103#else
104#define MPCI_RECEIVE_SERVER_FP (long) (sizeof( Context_Control_fp ))
105#endif
106
107#if (CPU_IDLE_TASK_IS_FP == TRUE)
108#define SYSTEM_IDLE_FP (long) (sizeof( Context_Control_fp ))
109#else
110#define SYSTEM_IDLE_FP (long) 0
111#endif
112
113#if !defined(RTEMS_MULTIPROCESSING)
114#define MPCI_RECEIVE_SERVER_STACK_SIZE 0
115#endif
116
117#if defined(RTEMS_MULTIPROCESSING)
118#define MPCI_RECEIVE_SERVER_STACK_SIZE \
119
120#define MP_SYSTEM_TASKS \
121   (STACK_MINIMUM_SIZE + CPU_MPCI_RECEIVE_SERVER_EXTRA_STACK + \
122    sizeof(Thread_Control) + \
123    MPCI_RECEIVE_SERVER_FP)
124
125extern CORE_semaphore_Control _MPCI_Semaphore;
126#else
127#define MP_SYSTEM_TASKS 0
128#endif
129
130/*
131 *  Idle and the MPCI Receive Server Threads
132 */
133
134#define SYSTEM_TASKS  \
135    (STACK_MINIMUM_SIZE + sizeof(Thread_Control) + SYSTEM_IDLE_FP + \
136     MP_SYSTEM_TASKS)
137
138uint32_t   sys_req;
139
140void size_rtems(
141  int mode
142)
143{
144int uninitialized = 0;
145int initialized = 0;
146
147/*
148 *  The following data is allocated for each Manager:
149 *
150 *    + Per Manager Object Information
151 *      - local pointer table
152 *      - local name table
153 *      - the object's control blocks
154 *      - global name chains
155 *
156 *  The following is the data allocate from the RTEMS Workspace Area.
157 *  The order indicates the order in which RTEMS allocates it.
158 *
159 *    + Object MP
160 *      - Global Object CB's
161 *    + Thread
162 *      - Ready Chain
163 *    + Thread MP
164 *      - Proxies Chain
165 *    + Interrupt Manager
166 *      - Interrupt Stack
167 *    + Timer Manager
168 *      - per Manager Object Data
169 *    + Extension Manager
170 *      - per Manager Object Data
171 *    + Message Queue Manager
172 *      - per Manager Object Data
173 *      - Message Buffers
174 *    + Semaphore Manager
175 *      - per Manager Object Data
176 *    + Partition Manager
177 *      - per Manager Object Data
178 *    + Region Manager
179 *      - per Manager Object Data
180 *    + Dual Ported Memory Manager
181 *      - per Manager Object Data
182 *    + Rate Monotonic Manager
183 *      - per Manager Object Data
184 *    + Internal Threads Handler
185 *      - MPCI Receive Server Thread TCB
186 *      - IDLE Thread TCB
187 *      - MPCI Receive Server Thread stack
188 *      - MPCI Receive Server Thread FP area (if CPU requires this)
189 *      - IDLE Thread stack
190 *      - IDLE Thread FP area (if CPU requires this)
191 *
192 *  This does not take into account any CPU dependent alignment requirements.
193 *
194 *  The following calculates the overhead needed by RTEMS from the
195 *  Workspace Area.
196 */
197sys_req = SYSTEM_TASKS     +     /* MPCI Receive Server and IDLE */
198          NAME_PTR_SIZE    +     /* Task Overhead */
199          READYCHAINS_SIZE +     /* Ready Chains */
200          NAME_PTR_SIZE    +     /* Timer Overhead */
201          NAME_PTR_SIZE    +     /* Semaphore Overhead */
202          NAME_PTR_SIZE    +     /* Message Queue Overhead */
203          NAME_PTR_SIZE    +     /* Region Overhead */
204          NAME_PTR_SIZE    +     /* Partition Overhead */
205          NAME_PTR_SIZE    +     /* Dual-Ported Memory Overhead */
206          NAME_PTR_SIZE    +     /* Rate Monotonic Overhead */
207          NAME_PTR_SIZE    +     /* Extension Overhead */
208          PER_NODE;              /* Extra Gobject Table */
209
210uninitialized =
211/*address.h*/   0                                         +
212
213/*apiext.h*/    (sizeof _API_extensions_List)             +
214
215/*asr.h*/       0                                         +
216
217/*attr.h*/      0                                         +
218
219/*bitfield.h*/  0                                         +
220
221/*chain.h*/     0                                         +
222
223/*clock.h*/     0                                         +
224
225/*config.h*/
226        #if defined(RTEMS_MULTIPROCESSING)
227                (sizeof _Configuration_MP_table)          +
228        #endif
229
230/*context.h*/   (sizeof _Context_Switch_necessary)        +
231
232/*copyrt.h*/    0                                         +
233
234/*debug.h*/     (sizeof _Debug_Level)                     +
235
236/*dpmem.h*/     (sizeof _Dual_ported_memory_Information)  +
237
238/*event.h*/     (sizeof _Event_Sync_state)                +
239
240#if defined(RTEMS_MULTIPROCESSING)
241/*eventmp.h*/   0                                         +
242#endif
243
244/*eventset.h*/  0                                         +
245
246/*extension.h*/ (sizeof _Extension_Information)           +
247
248/*fatal.h*/     0                                         +
249
250/*heap.h*/      0                                         +
251
252/*init.h*/      0                                         +
253
254/*interr.h*/    (sizeof _Internal_errors_What_happened)   +
255
256/*intr.h*/      0                                         +
257
258/*io.h*/        (sizeof _IO_Number_of_drivers)            +
259                (sizeof _IO_Driver_address_table)         +
260
261/*isr.h*/       (sizeof _ISR_Nest_level)                  +
262#if (CPU_SIMPLE_VECTORED_INTERRUPTS == TRUE)
263                (sizeof _ISR_Vector_table)                +
264#endif
265                (sizeof _ISR_Signals_to_thread_executing) +
266
267/*message.h*/   (sizeof _Message_queue_Information)       +
268
269/*modes.h*/     0                                         +
270
271#if defined(RTEMS_MULTIPROCESSING)
272/*mp.h*/        0                                         +
273#endif
274
275#if defined(RTEMS_MULTIPROCESSING)
276/*mpci.h*/      (sizeof _MPCI_Remote_blocked_threads)     +
277                (sizeof _MPCI_Semaphore)                  +
278                (sizeof _MPCI_table)                      +
279                (sizeof _MPCI_Receive_server_tcb)         +
280                (sizeof _MPCI_Packet_processors)          +
281#endif
282
283#if defined(RTEMS_MULTIPROCESSING)
284/*mppkt.h*/     0                                         +
285#endif
286
287#if defined(RTEMS_MULTIPROCESSING)
288/*mptables.h*/  0                                         +
289#endif
290
291#if defined(RTEMS_MULTIPROCESSING)
292/*msgmp.h*/     0                                         +
293#endif
294
295/*object.h*/    (sizeof _Objects_Local_node)              +
296                (sizeof _Objects_Maximum_nodes)           +
297                (sizeof _Objects_Information_table)       +
298
299#if defined(RTEMS_MULTIPROCESSING)
300/*objectmp.h*/  (sizeof _Objects_MP_Maximum_global_objects) +
301                (sizeof _Objects_MP_Inactive_global_objects) +
302#endif
303
304/*options.h*/   0                                         +
305
306/*part.h*/      (sizeof _Partition_Information)           +
307
308#if defined(RTEMS_MULTIPROCESSING)
309/*partmp.h*/    0                                         +
310#endif
311
312/*priority.h*/  (sizeof _Priority_Major_bit_map)          +
313                (sizeof _Priority_Bit_map)                +
314
315/*ratemon.h*/   (sizeof _Rate_monotonic_Information)      +
316
317/*region.h*/    (sizeof _Region_Information)              +
318
319#if defined(RTEMS_MULTIPROCESSING)
320/*regionmp.h*/  0                                         +
321#endif
322
323/*rtems.h*/     /* Not applicable */
324
325/*sem.h*/       (sizeof _Semaphore_Information)           +
326
327#if defined(RTEMS_MULTIPROCESSING)
328/*semmp.h*/     0                                         +
329#endif
330
331/*signal.h*/    0                                         +
332
333/*signalmp.h*/  0                                         +
334
335/*stack.h*/     0                                         +
336
337/*states.h*/    0                                         +
338
339/*status.h*/    0                                         +
340
341/*sysstate.h*/  (sizeof _System_state_Current)            +
342#if defined(RTEMS_MULTIPROCESSING)
343                (sizeof _System_state_Is_multiprocessing) +
344#endif
345
346#if defined(RTEMS_MULTIPROCESSING)
347/*taskmp.h*/    0                                         +
348#endif
349
350/*tasks.h*/     (sizeof _RTEMS_tasks_Information)         +
351
352/*thread.h*/    (sizeof _Thread_BSP_context)              +
353                (sizeof _Thread_Dispatch_disable_level)   +
354                (sizeof _Thread_Do_post_task_switch_extension) +
355                (sizeof _Thread_Maximum_extensions)       +
356                (sizeof _Thread_Ticks_per_timeslice)      +
357                (sizeof _Thread_Ready_chain)              +
358                (sizeof _Thread_Executing)                +
359                (sizeof _Thread_Heir)                     +
360#if (CPU_HARDWARE_FP == 1) || (CPU_SOFTWARE_FP == 1)
361                (sizeof _Thread_Allocated_fp)             +
362#endif
363                (sizeof _Thread_Internal_information)     +
364                (sizeof _Thread_Idle)                     +
365
366#if defined(RTEMS_MULTIPROCESSING)
367/*threadmp.h*/  (sizeof _Thread_MP_Active_proxies)        +
368                (sizeof _Thread_MP_Inactive_proxies)      +
369#endif
370
371/*threadq.h*/
372
373/*timer.h*/     (sizeof _Timer_Information)               +
374
375/*tod.h*/       (sizeof _TOD_Now)                         +
376                (sizeof _TOD_Uptime)                      +
377
378/*tqdata.h*/    0                                         +
379
380/*types.h*/     0                                         +
381
382/*userext.h*/   (sizeof _User_extensions_List)            +
383
384/*watchdog.h*/  (sizeof _Watchdog_Sync_level)             +
385                (sizeof _Watchdog_Sync_count)             +
386                (sizeof _Watchdog_Ticks_since_boot)       +
387                (sizeof _Watchdog_Ticks_chain)            +
388                (sizeof _Watchdog_Seconds_chain)          +
389
390/*wkspace.h*/   (sizeof _Workspace_Area);
391
392uninitialized = 0;
393
394#ifndef unix  /* make sure this is not a native compile */
395
396#ifdef __i386__
397
398/* cpu.h */
399uninitialized += (sizeof _CPU_Null_fp_context);
400
401#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
402uninitialized += (sizeof _CPU_Interrupt_stack_low) +
403                 (sizeof _CPU_Interrupt_stack_high);
404#endif
405
406#endif
407
408#ifdef __mc68000__
409
410/* cpu.h */
411uninitialized += (sizeof _CPU_Interrupt_stack_low) +
412                 (sizeof _CPU_Interrupt_stack_high);
413
414#endif
415
416#ifdef __sparc__
417
418/* cpu.h */
419uninitialized += (sizeof _CPU_Interrupt_stack_low) +
420                 (sizeof _CPU_Interrupt_stack_high) +
421                 (sizeof _CPU_Null_fp_context);
422
423#endif
424
425
426#ifdef no_cpu
427
428/* cpu.h */
429uninitialized += (sizeof _CPU_Null_fp_context) +
430                 (sizeof _CPU_Interrupt_stack_low) +
431                 (sizeof _CPU_Interrupt_stack_high) +
432                 (sizeof _CPU_Thread_dispatch_pointer);
433
434#endif
435
436#ifdef __PPC__
437
438/* cpu.h */
439uninitialized += (sizeof _CPU_Interrupt_stack_low) +
440                 (sizeof _CPU_Interrupt_stack_high) +
441                 (sizeof _CPU_IRQ_info);
442
443#endif
444#endif /* !unix */
445
446initialized +=
447/*copyrt.h*/    (strlen(_Copyright_Notice)+1)             +
448
449#if defined(RTEMS_MULTIPROCESSING)
450/*sptables.h*/  (sizeof _Initialization_Default_multiprocessing_table)  +
451#endif
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 intialized 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_PORT * 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  - %04d                 =  %d\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  - %d\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.