source: rtems/testsuites/sptests/spsize/size.c @ 4b61ebfb

4.104.114.84.9
Last change on this file since 4b61ebfb was 3a4ae6c, checked in by Joel Sherrill <joel.sherrill@…>, on Sep 11, 1995 at 7:35:39 PM

The word "RTEMS" almost completely removed from the core.

Configuration Table Template file added and all tests
modified to use this. All gvar.h and conftbl.h files
removed from test directories.

Configuration parameter maximum_devices added.

Core semaphore and mutex handlers added and RTEMS API Semaphore
Manager updated to reflect this.

Initialization sequence changed to invoke API specific initialization
routines. Initialization tasks table now owned by RTEMS Tasks Manager.

Added user extension for post-switch.

Utilized user extensions to implement API specific functionality
like signal dispatching.

Added extensions to the System Initialization Thread so that an
API can register a function to be invoked while the system
is being initialized. These are largely equivalent to the
pre-driver and post-driver hooks.

Added the Modules file oar-go32_p5, modified oar-go32, and modified
the file make/custom/go32.cfg to look at an environment varable which
determines what CPU model is being used.

All BSPs updated to reflect named devices and clock driver's IOCTL
used by the Shared Memory Driver. Also merged clock isr into
main file and removed ckisr.c where possible.

Updated spsize to reflect new and moved variables.

Makefiles for the executive source and include files updated to show
break down of files into Core, RTEMS API, and Neither.

Header and inline files installed into subdirectory based on whether
logically in the Core or a part of the RTEMS API.

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