source: rtems/testsuites/sptests/spsize/size.c @ 84f5c0a

5
Last change on this file since 84f5c0a was 84f5c0a, checked in by Sebastian Huber <sebastian.huber@…>, on 04/04/16 at 07:42:15

score: Use red-black tree for active global objects

Use a red-black tree to lookup active global objects by identifier or
name.

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