source: rtems/testsuites/sptests/spsize/size.c @ 21275b58

Last change on this file since 21275b58 was 21275b58, checked in by Sebastian Huber <sebastian.huber@…>, on Nov 22, 2018 at 6:14:51 PM

score: Static Objects_Information initialization

Statically allocate the objects information together with the initial
set of objects either via <rtems/confdefs.h>. Provide default object
informations with zero objects via librtemscpu.a. This greatly
simplifies the workspace size estimate. RTEMS applications which do not
use the unlimited objects option are easier to debug since all objects
reside now in statically allocated objects of the right types.

Close #3621.

  • Property mode set to 100644
File size: 19.8 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_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
394uninitialized += (sizeof _CPU_Interrupt_stack_low) +
395                 (sizeof _CPU_Interrupt_stack_high);
396
397#endif
398
399#ifdef __mc68000__
400
401/* cpu.h */
402uninitialized += (sizeof _CPU_Interrupt_stack_low) +
403                 (sizeof _CPU_Interrupt_stack_high);
404
405#endif
406
407#ifdef __sparc__
408
409/* cpu.h */
410uninitialized += (sizeof _CPU_Interrupt_stack_low) +
411                 (sizeof _CPU_Interrupt_stack_high);
412
413#endif
414
415
416#ifdef no_cpu
417
418/* cpu.h */
419uninitialized += (sizeof _CPU_Null_fp_context) +
420                 (sizeof _CPU_Interrupt_stack_low) +
421                 (sizeof _CPU_Interrupt_stack_high) +
422                 (sizeof _CPU_Thread_dispatch_pointer);
423
424#endif
425
426#ifdef __PPC__
427
428/* cpu.h */
429uninitialized += (sizeof _CPU_Interrupt_stack_low) +
430                 (sizeof _CPU_Interrupt_stack_high);
431
432#endif
433#endif /* !unix */
434
435initialized +=
436/*copyrt.h*/    (strlen(_Copyright_Notice)+1)             +
437
438#if defined(RTEMS_MULTIPROCESSING)
439                (sizeof _Initialization_Default_multiprocessing_table)  +
440#endif
441                (strlen(_RTEMS_version)+1);
442
443
444
445#ifndef unix /* make sure this is not native */
446#ifdef __sparc__
447
448initialized +=  (sizeof _CPU_Trap_slot_template);
449
450#endif
451#endif /* !unix */
452
453puts( "" );
454
455  if ( mode == 0 ) help_size();
456  else             print_formula();
457
458printf( "\n" );
459printf( "RTEMS uninitialized data consumes %d bytes\n", uninitialized );
460printf( "RTEMS initialized data consumes %d bytes\n", initialized );
461
462}
463
464void help_size()
465{
466int c = '\0';
467int break_loop;
468int total_size;
469int task_stacks;
470int interrupt_stack;
471int maximum_tasks, size_tasks;
472int maximum_sems, size_sems;
473int maximum_timers, size_timers;
474int maximum_msgqs, size_msgqs;
475int maximum_msgs, size_msgs_overhead;
476int maximum_regns, size_regns;
477int maximum_parts, size_parts;
478int maximum_ports, size_ports;
479int maximum_periods, size_periods;
480int maximum_extensions, size_extensions;
481int maximum_drvs, size_drvs;
482int maximum_fps, size_fps;
483int maximum_nodes, size_nodes;
484int maximum_gobjs, size_gobjs;
485int maximum_proxies, size_proxies;
486
487total_size = sys_req;    /* Fixed Overhead */
488printf( "What is maximum_tasks? " );
489maximum_tasks = getint();
490size_tasks = PER_TASK * maximum_tasks;
491total_size += size_tasks;
492
493printf( "What is maximum_semaphores? " );
494maximum_sems = getint();
495size_sems = PER_SEMAPHORE * maximum_sems;
496total_size += size_sems;
497
498printf( "What is maximum_timers? " );
499maximum_timers = getint();
500size_timers = PER_TIMER * maximum_timers;
501total_size += size_timers;
502
503printf( "What is maximum_message_queues? " );
504maximum_msgqs = getint();
505size_msgqs = PER_MSGQ * maximum_msgqs;
506total_size += size_msgqs;
507
508printf( "What is maximum_messages?  XXXX " );
509maximum_msgs = getint();
510size_msgs_overhead = 0;
511total_size += size_msgs_overhead;
512
513printf( "What is maximum_regions? " );
514maximum_regns = getint();
515size_regns = PER_REGN * maximum_regns;
516total_size += size_regns;
517
518printf( "What is maximum_partitions? " );
519maximum_parts = getint();
520size_parts = PER_PART * maximum_parts;
521total_size += size_parts;
522
523printf( "What is maximum_ports? " );
524maximum_ports = getint();
525size_ports = PER_PORT * maximum_ports;
526total_size += size_ports;
527
528printf( "What is maximum_periods? " );
529maximum_periods = getint();
530size_periods = PER_PERIOD * maximum_periods;
531total_size += size_periods;
532
533printf( "What is maximum_extensions? " );
534maximum_extensions = getint();
535size_extensions = PER_EXTENSION * maximum_extensions;
536total_size += size_extensions;
537
538printf( "What is number_of_device_drivers? " );
539maximum_drvs = getint();
540size_drvs = PER_DRV  * maximum_drvs;
541total_size += size_drvs;
542
543printf( "What will be total stack requirement for all tasks? " );
544task_stacks = getint();
545total_size += task_stacks;
546
547printf( "What is the size of the interrupt stack? " );
548interrupt_stack = getint();
549total_size += interrupt_stack;
550
551printf( "How many tasks will be created with the FP flag? " );
552maximum_fps = getint();
553size_fps = PER_FPTASK  * maximum_fps;
554total_size += size_fps;
555
556printf( "Is this a single processor system? " );
557for ( break_loop=0 ; !break_loop; c = getchar() ) {
558  switch ( c ) {
559    case 'Y':  case 'y':
560    case 'N':  case 'n':
561      break_loop = 1;
562      break;
563  }
564}
565printf( "%c\n", c );
566if ( c == 'n' || c == 'N' ) {
567  printf( "What is maximum_nodes? " );
568  maximum_nodes = getint();
569  size_nodes = PER_NODE * maximum_nodes;
570  total_size += size_nodes;
571  printf( "What is maximum_global_objects? " );
572  maximum_gobjs = getint();
573  size_gobjs = PER_GOBJECT * maximum_gobjs;
574  total_size += size_gobjs;
575  printf( "What is maximum_proxies? " );
576  maximum_proxies = getint();
577  size_proxies = PER_PROXY * maximum_proxies;
578  total_size += size_proxies;
579} else {
580  maximum_nodes = 0;
581  size_nodes = PER_NODE * 0;
582  maximum_gobjs = 0;
583  size_gobjs = PER_GOBJECT * 0;
584  maximum_proxies = 0;
585  size_proxies = PER_PROXY * 0;
586}
587
588printf( "\n\n" );
589printf( " ************** EXECUTIVE WORK SPACE REQUIRED **************\n" );
590printf( " Tasks                - %03d * %03ld            =  %ld\n",
591          maximum_tasks, PER_TASK, (long) size_tasks );
592printf( " Semaphores           - %03d * %03ld            =  %ld\n",
593          maximum_sems, PER_SEMAPHORE, (long) size_sems );
594printf( " Timers               - %03d * %03ld            =  %ld\n",
595          maximum_timers, PER_TIMER, (long) size_timers );
596printf( " Msg Queues           - %03d * %03ld            =  %ld\n",
597          maximum_msgqs, PER_MSGQ, (long) size_msgqs );
598printf( " Messages Overhead    - %03d * %03d            =  %ld\n",
599          maximum_msgs, 0 /* PER_MSG_OVERHEAD */, (long) size_msgs_overhead );
600printf( " Regions              - %03d * %03ld            =  %ld\n",
601          maximum_regns, PER_REGN, (long) size_regns);
602printf( " Partitions           - %03d * %03ld            =  %ld\n",
603          maximum_parts, PER_PART, (long) size_parts );
604printf( " Periods              - %03d * %03ld            =  %ld\n",
605          maximum_periods, PER_PERIOD, (long) size_periods );
606printf( " Extensions           - %03d * %03ld            =  %ld\n",
607          maximum_extensions, PER_EXTENSION, (long) size_extensions );
608printf( " Device Drivers       - %03d * %03ld            =  %ld\n",
609          maximum_drvs, PER_DRV, (long) size_drvs );
610
611printf( " System Requirements  - %04" PRIu32 "                 =  %"PRIu32 "\n",
612          sys_req, sys_req );
613
614printf( " Floating Point Tasks - %03d * %03ld            =  %ld\n",
615          maximum_fps, PER_FPTASK, (long) size_fps );
616printf( " Application Task Stacks -                     =  %d\n",
617          task_stacks );
618printf( " Interrupt Stacks -                            =  %d\n",
619          task_stacks );
620printf( " \n" );
621printf( " Global object tables - %03d * %03ld            =  %ld\n",
622          maximum_nodes, PER_NODE, (long) size_nodes );
623printf( " Global objects       - %03d * %03ld            =  %ld\n",
624          maximum_gobjs, PER_GOBJECT, (long) size_gobjs );
625printf( " Proxies              - %03d * %03ld            =  %ld\n",
626          maximum_proxies, PER_PROXY, (long) size_proxies );
627printf( "\n\n" );
628printf( " TOTAL                                       = %d bytes\n",
629      total_size );
630}
631
632void print_formula()
633{
634printf( " ************** EXECUTIVE WORK SPACE FORMULA **************\n" );
635printf( " Tasks                - maximum_tasks * %ld\n",      PER_TASK );
636printf( " Timers               - maximum_timers * %ld\n",     PER_TIMER );
637printf( " Semaphores           - maximum_semaphores * %ld\n", PER_SEMAPHORE);
638printf( " Message Queues       - maximum_message_queues * %ld\n", PER_MSGQ );
639printf( " Messages             -\n");
640printf( " Regions              - maximum_regions * %ld\n",    PER_REGN );
641printf( " Partitions           - maximum_partitions * %ld\n", PER_PART );
642printf( " Ports                - maximum_ports * %ld\n",      PER_PORT );
643printf( " Periods              - maximum_periods * %ld\n",    PER_PORT );
644printf( " Extensions           - maximum_extensions * %ld\n", PER_EXTENSION );
645printf( " Device Drivers       - number_of_device_drivers * %ld\n", PER_DRV);
646printf( " System Requirements  - %" PRIu32 "\n",              sys_req );
647printf( " Floating Point Tasks - FPMASK Tasks * %ld\n",       PER_FPTASK );
648printf( " User's Tasks' Stacks -\n" );
649printf( " Interrupt Stack      -\n" );
650printf( " \n" );
651printf( " Global object tables - maximum_nodes * %ld\n",          PER_NODE );
652printf( " Global objects       - maximum_global_objects * %ld\n", PER_GOBJECT );
653printf( " Proxies              - maximum_proxies * %ld\n",        PER_PROXY );
654}
Note: See TracBrowser for help on using the repository browser.