/* main
|
/* main
|
*
|
*
|
* This program is run to determine the data space and work space
|
* This program is run to determine the data space and work space
|
* requirements of the current version of RTEMS.
|
* requirements of the current version of RTEMS.
|
*
|
*
|
* COPYRIGHT (c) 1989-1999.
|
* COPYRIGHT (c) 1989-1999.
|
* On-Line Applications Research Corporation (OAR).
|
* On-Line Applications Research Corporation (OAR).
|
*
|
*
|
* The license and distribution terms for this file may be
|
* The license and distribution terms for this file may be
|
* found in the file LICENSE in this distribution or at
|
* found in the file LICENSE in this distribution or at
|
* http://www.OARcorp.com/rtems/license.html.
|
* http://www.OARcorp.com/rtems/license.html.
|
*
|
*
|
* $Id: size.c,v 1.2 2001-09-27 12:02:38 chris Exp $
|
* $Id: size.c,v 1.2 2001-09-27 12:02:38 chris Exp $
|
*/
|
*/
|
|
|
#include <rtems/system.h>
|
#include <rtems/system.h>
|
#include <rtems/config.h>
|
#include <rtems/config.h>
|
#include <rtems/directives.h>
|
#include <rtems/directives.h>
|
#include <rtems/score/apiext.h>
|
#include <rtems/score/apiext.h>
|
#include <rtems/score/copyrt.h>
|
#include <rtems/score/copyrt.h>
|
#include <rtems/rtems/clock.h>
|
#include <rtems/rtems/clock.h>
|
#include <rtems/rtems/tasks.h>
|
#include <rtems/rtems/tasks.h>
|
#include <rtems/rtems/dpmem.h>
|
#include <rtems/rtems/dpmem.h>
|
#include <rtems/rtems/event.h>
|
#include <rtems/rtems/event.h>
|
#include <rtems/extension.h>
|
#include <rtems/extension.h>
|
#include <rtems/fatal.h>
|
#include <rtems/fatal.h>
|
#include <rtems/init.h>
|
#include <rtems/init.h>
|
#include <rtems/score/isr.h>
|
#include <rtems/score/isr.h>
|
#include <rtems/rtems/intr.h>
|
#include <rtems/rtems/intr.h>
|
#include <rtems/io.h>
|
#include <rtems/io.h>
|
#include <rtems/rtems/message.h>
|
#include <rtems/rtems/message.h>
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
#include <rtems/rtems/mp.h>
|
#include <rtems/rtems/mp.h>
|
#include <rtems/score/mpci.h>
|
#include <rtems/score/mpci.h>
|
#endif
|
#endif
|
#include <rtems/rtems/part.h>
|
#include <rtems/rtems/part.h>
|
#include <rtems/score/priority.h>
|
#include <rtems/score/priority.h>
|
#include <rtems/rtems/ratemon.h>
|
#include <rtems/rtems/ratemon.h>
|
#include <rtems/rtems/region.h>
|
#include <rtems/rtems/region.h>
|
#include <rtems/rtems/sem.h>
|
#include <rtems/rtems/sem.h>
|
#include <rtems/rtems/signal.h>
|
#include <rtems/rtems/signal.h>
|
#include <rtems/score/sysstate.h>
|
#include <rtems/score/sysstate.h>
|
#include <rtems/score/thread.h>
|
#include <rtems/score/thread.h>
|
#include <rtems/rtems/timer.h>
|
#include <rtems/rtems/timer.h>
|
#include <rtems/score/tod.h>
|
#include <rtems/score/tod.h>
|
#include <rtems/score/userext.h>
|
#include <rtems/score/userext.h>
|
#include <rtems/score/wkspace.h>
|
#include <rtems/score/wkspace.h>
|
|
|
#include <stdlib.h>
|
#include <stdlib.h>
|
|
|
/* These are always defined by the executive.
|
/* These are always defined by the executive.
|
*
|
*
|
* #include <rtems/copyrt.h>
|
* #include <rtems/copyrt.h>
|
* #include <rtems/tables.h>
|
* #include <rtems/tables.h>
|
* #include <rtems/sptables.h>
|
* #include <rtems/sptables.h>
|
*/
|
*/
|
#define HEAP_OVHD 16 /* wasted heap space per task stack */
|
#define HEAP_OVHD 16 /* wasted heap space per task stack */
|
#define NAME_PTR_SIZE 8 /* size of name and pointer table entries */
|
#define NAME_PTR_SIZE 8 /* size of name and pointer table entries */
|
#define READYCHAINS_SIZE \
|
#define READYCHAINS_SIZE \
|
((RTEMS_MAXIMUM_PRIORITY + 1) * sizeof(Chain_Control ))
|
((RTEMS_MAXIMUM_PRIORITY + 1) * sizeof(Chain_Control ))
|
|
|
#define PER_TASK \
|
#define PER_TASK \
|
(long) (sizeof (Thread_Control) + \
|
(long) (sizeof (Thread_Control) + \
|
NAME_PTR_SIZE + HEAP_OVHD + sizeof( RTEMS_API_Control ))
|
NAME_PTR_SIZE + HEAP_OVHD + sizeof( RTEMS_API_Control ))
|
#define PER_SEMAPHORE \
|
#define PER_SEMAPHORE \
|
(long) (sizeof (Semaphore_Control) + NAME_PTR_SIZE)
|
(long) (sizeof (Semaphore_Control) + NAME_PTR_SIZE)
|
#define PER_TIMER \
|
#define PER_TIMER \
|
(long) (sizeof (Timer_Control) + NAME_PTR_SIZE)
|
(long) (sizeof (Timer_Control) + NAME_PTR_SIZE)
|
#define PER_MSGQ \
|
#define PER_MSGQ \
|
(long) (sizeof (Message_queue_Control) + NAME_PTR_SIZE)
|
(long) (sizeof (Message_queue_Control) + NAME_PTR_SIZE)
|
#define PER_REGN \
|
#define PER_REGN \
|
(long) (sizeof (Region_Control) + NAME_PTR_SIZE)
|
(long) (sizeof (Region_Control) + NAME_PTR_SIZE)
|
#define PER_PART \
|
#define PER_PART \
|
(long) (sizeof (Partition_Control) + NAME_PTR_SIZE)
|
(long) (sizeof (Partition_Control) + NAME_PTR_SIZE)
|
#define PER_PERIOD \
|
#define PER_PERIOD \
|
(long) (sizeof (Rate_monotonic_Control) + NAME_PTR_SIZE)
|
(long) (sizeof (Rate_monotonic_Control) + NAME_PTR_SIZE)
|
#define PER_PORT \
|
#define PER_PORT \
|
(long) (sizeof (Dual_ported_memory_Control) + NAME_PTR_SIZE)
|
(long) (sizeof (Dual_ported_memory_Control) + NAME_PTR_SIZE)
|
#define PER_EXTENSION \
|
#define PER_EXTENSION \
|
(long) (sizeof (Extension_Control) + NAME_PTR_SIZE)
|
(long) (sizeof (Extension_Control) + NAME_PTR_SIZE)
|
|
|
#define PER_DRV (long) (0)
|
#define PER_DRV (long) (0)
|
#define PER_FPTASK (long) (CONTEXT_FP_SIZE)
|
#define PER_FPTASK (long) (CONTEXT_FP_SIZE)
|
#define PER_GOBTBL (long) (sizeof (Chain_Control)*4)
|
#define PER_GOBTBL (long) (sizeof (Chain_Control)*4)
|
#define PER_NODE (long) PER_GOBTBL
|
#define PER_NODE (long) PER_GOBTBL
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
#define PER_GOBJECT (long) (sizeof (Objects_MP_Control))
|
#define PER_GOBJECT (long) (sizeof (Objects_MP_Control))
|
#else
|
#else
|
#define PER_GOBJECT (long) 0
|
#define PER_GOBJECT (long) 0
|
#endif
|
#endif
|
#define PER_PROXY (long) (sizeof (Thread_Proxy_control))
|
#define PER_PROXY (long) (sizeof (Thread_Proxy_control))
|
|
|
#if !defined(RTEMS_MULTIPROCESSING) || (CPU_ALL_TASKS_ARE_FP != TRUE)
|
#if !defined(RTEMS_MULTIPROCESSING) || (CPU_ALL_TASKS_ARE_FP != TRUE)
|
#define MPCI_RECEIVE_SERVER_FP (long) 0
|
#define MPCI_RECEIVE_SERVER_FP (long) 0
|
#else
|
#else
|
#define MPCI_RECEIVE_SERVER_FP (long) (sizeof( Context_Control_fp ))
|
#define MPCI_RECEIVE_SERVER_FP (long) (sizeof( Context_Control_fp ))
|
#endif
|
#endif
|
|
|
#if (CPU_IDLE_TASK_IS_FP == TRUE)
|
#if (CPU_IDLE_TASK_IS_FP == TRUE)
|
#define SYSTEM_IDLE_FP (long) (sizeof( Context_Control_fp ))
|
#define SYSTEM_IDLE_FP (long) (sizeof( Context_Control_fp ))
|
#else
|
#else
|
#define SYSTEM_IDLE_FP (long) 0
|
#define SYSTEM_IDLE_FP (long) 0
|
#endif
|
#endif
|
|
|
#if !defined(RTEMS_MULTIPROCESSING)
|
#if !defined(RTEMS_MULTIPROCESSING)
|
#define MPCI_RECEIVE_SERVER_STACK_SIZE 0
|
#define MPCI_RECEIVE_SERVER_STACK_SIZE 0
|
#endif
|
#endif
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
#define MP_SYSTEM_TASKS \
|
#define MP_SYSTEM_TASKS \
|
(MPCI_RECEIVE_SERVER_STACK_SIZE + \
|
(MPCI_RECEIVE_SERVER_STACK_SIZE + \
|
sizeof(Thread_Control) + \
|
sizeof(Thread_Control) + \
|
MPCI_RECEIVE_SERVER_FP)
|
MPCI_RECEIVE_SERVER_FP)
|
#else
|
#else
|
#define MP_SYSTEM_TASKS 0
|
#define MP_SYSTEM_TASKS 0
|
#endif
|
#endif
|
|
|
/*
|
/*
|
* Idle and the MPCI Receive Server Threads
|
* Idle and the MPCI Receive Server Threads
|
*/
|
*/
|
|
|
#define SYSTEM_TASKS \
|
#define SYSTEM_TASKS \
|
(STACK_MINIMUM_SIZE + sizeof(Thread_Control) + SYSTEM_IDLE_FP + \
|
(STACK_MINIMUM_SIZE + sizeof(Thread_Control) + SYSTEM_IDLE_FP + \
|
MP_SYSTEM_TASKS)
|
MP_SYSTEM_TASKS)
|
|
|
#define rtems_unsigned32 unsigned32
|
#define rtems_unsigned32 unsigned32
|
|
|
rtems_unsigned32 sys_req;
|
rtems_unsigned32 sys_req;
|
|
|
/* to avoid warnings */
|
/* to avoid warnings */
|
int puts();
|
int puts();
|
int printf();
|
int printf();
|
int getint();
|
int getint();
|
#undef getchar
|
#undef getchar
|
int getchar();
|
int getchar();
|
void help_size();
|
void help_size();
|
void print_formula();
|
void print_formula();
|
|
|
void size_rtems(
|
void size_rtems(
|
int mode
|
int mode
|
)
|
)
|
{
|
{
|
int uninitialized = 0;
|
int uninitialized = 0;
|
int initialized = 0;
|
int initialized = 0;
|
|
|
/*
|
/*
|
* The following data is allocated for each Manager:
|
* The following data is allocated for each Manager:
|
*
|
*
|
* + Per Manager Object Information
|
* + Per Manager Object Information
|
* - local pointer table
|
* - local pointer table
|
* - local name table
|
* - local name table
|
* - the object's control blocks
|
* - the object's control blocks
|
* - global name chains
|
* - global name chains
|
*
|
*
|
* The following is the data allocate from the RTEMS Workspace Area.
|
* The following is the data allocate from the RTEMS Workspace Area.
|
* The order indicates the order in which RTEMS allocates it.
|
* The order indicates the order in which RTEMS allocates it.
|
*
|
*
|
* + Object MP
|
* + Object MP
|
* - Global Object CB's
|
* - Global Object CB's
|
* + Thread
|
* + Thread
|
* - Ready Chain
|
* - Ready Chain
|
* + Thread MP
|
* + Thread MP
|
* - Proxies Chain
|
* - Proxies Chain
|
* + Interrupt Manager
|
* + Interrupt Manager
|
* - Interrupt Stack
|
* - Interrupt Stack
|
* + Timer Manager
|
* + Timer Manager
|
* - per Manager Object Data
|
* - per Manager Object Data
|
* + Extension Manager
|
* + Extension Manager
|
* - per Manager Object Data
|
* - per Manager Object Data
|
* + Message Queue Manager
|
* + Message Queue Manager
|
* - per Manager Object Data
|
* - per Manager Object Data
|
* - Message Buffers
|
* - Message Buffers
|
* + Semaphore Manager
|
* + Semaphore Manager
|
* - per Manager Object Data
|
* - per Manager Object Data
|
* + Partition Manager
|
* + Partition Manager
|
* - per Manager Object Data
|
* - per Manager Object Data
|
* + Region Manager
|
* + Region Manager
|
* - per Manager Object Data
|
* - per Manager Object Data
|
* + Dual Ported Memory Manager
|
* + Dual Ported Memory Manager
|
* - per Manager Object Data
|
* - per Manager Object Data
|
* + Rate Monotonic Manager
|
* + Rate Monotonic Manager
|
* - per Manager Object Data
|
* - per Manager Object Data
|
* + Internal Threads Handler
|
* + Internal Threads Handler
|
* - MPCI Receive Server Thread TCB
|
* - MPCI Receive Server Thread TCB
|
* - IDLE Thread TCB
|
* - IDLE Thread TCB
|
* - MPCI Receive Server Thread stack
|
* - MPCI Receive Server Thread stack
|
* - MPCI Receive Server Thread FP area (if CPU requires this)
|
* - MPCI Receive Server Thread FP area (if CPU requires this)
|
* - IDLE Thread stack
|
* - IDLE Thread stack
|
* - IDLE Thread FP area (if CPU requires this)
|
* - IDLE Thread FP area (if CPU requires this)
|
*
|
*
|
* This does not take into account any CPU dependent alignment requirements.
|
* This does not take into account any CPU dependent alignment requirements.
|
*
|
*
|
* The following calculates the overhead needed by RTEMS from the
|
* The following calculates the overhead needed by RTEMS from the
|
* Workspace Area.
|
* Workspace Area.
|
*/
|
*/
|
sys_req = SYSTEM_TASKS + /* MPCI Receive Server and IDLE */
|
sys_req = SYSTEM_TASKS + /* MPCI Receive Server and IDLE */
|
NAME_PTR_SIZE + /* Task Overhead */
|
NAME_PTR_SIZE + /* Task Overhead */
|
READYCHAINS_SIZE + /* Ready Chains */
|
READYCHAINS_SIZE + /* Ready Chains */
|
NAME_PTR_SIZE + /* Timer Overhead */
|
NAME_PTR_SIZE + /* Timer Overhead */
|
NAME_PTR_SIZE + /* Semaphore Overhead */
|
NAME_PTR_SIZE + /* Semaphore Overhead */
|
NAME_PTR_SIZE + /* Message Queue Overhead */
|
NAME_PTR_SIZE + /* Message Queue Overhead */
|
NAME_PTR_SIZE + /* Region Overhead */
|
NAME_PTR_SIZE + /* Region Overhead */
|
NAME_PTR_SIZE + /* Partition Overhead */
|
NAME_PTR_SIZE + /* Partition Overhead */
|
NAME_PTR_SIZE + /* Dual-Ported Memory Overhead */
|
NAME_PTR_SIZE + /* Dual-Ported Memory Overhead */
|
NAME_PTR_SIZE + /* Rate Monotonic Overhead */
|
NAME_PTR_SIZE + /* Rate Monotonic Overhead */
|
NAME_PTR_SIZE + /* Extension Overhead */
|
NAME_PTR_SIZE + /* Extension Overhead */
|
PER_NODE; /* Extra Gobject Table */
|
PER_NODE; /* Extra Gobject Table */
|
|
|
uninitialized =
|
uninitialized =
|
/*address.h*/ 0 +
|
/*address.h*/ 0 +
|
|
|
/*apiext.h*/ (sizeof _API_extensions_List) +
|
/*apiext.h*/ (sizeof _API_extensions_List) +
|
|
|
/*asr.h*/ 0 +
|
/*asr.h*/ 0 +
|
|
|
/*attr.h*/ 0 +
|
/*attr.h*/ 0 +
|
|
|
/*bitfield.h*/ 0 +
|
/*bitfield.h*/ 0 +
|
|
|
/*chain.h*/ 0 +
|
/*chain.h*/ 0 +
|
|
|
/*clock.h*/ 0 +
|
/*clock.h*/ 0 +
|
|
|
/*config.h*/ (sizeof _Configuration_Table) +
|
/*config.h*/ (sizeof _Configuration_Table) +
|
(sizeof _Configuration_MP_table) +
|
(sizeof _Configuration_MP_table) +
|
|
|
/*context.h*/ (sizeof _Context_Switch_necessary) +
|
/*context.h*/ (sizeof _Context_Switch_necessary) +
|
|
|
/*copyrt.h*/ 0 +
|
/*copyrt.h*/ 0 +
|
|
|
/*debug.h*/ (sizeof _Debug_Level) +
|
/*debug.h*/ (sizeof _Debug_Level) +
|
|
|
/*dpmem.h*/ (sizeof _Dual_ported_memory_Information) +
|
/*dpmem.h*/ (sizeof _Dual_ported_memory_Information) +
|
|
|
/*event.h*/ (sizeof _Event_Sync_state) +
|
/*event.h*/ (sizeof _Event_Sync_state) +
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
/*eventmp.h*/ 0 +
|
/*eventmp.h*/ 0 +
|
#endif
|
#endif
|
|
|
/*eventset.h*/ 0 +
|
/*eventset.h*/ 0 +
|
|
|
/*extension.h*/ (sizeof _Extension_Information) +
|
/*extension.h*/ (sizeof _Extension_Information) +
|
|
|
/*fatal.h*/ 0 +
|
/*fatal.h*/ 0 +
|
|
|
/*heap.h*/ 0 +
|
/*heap.h*/ 0 +
|
|
|
/*init.h*/ 0 +
|
/*init.h*/ 0 +
|
|
|
/*interr.h*/ (sizeof Internal_errors_What_happened) +
|
/*interr.h*/ (sizeof Internal_errors_What_happened) +
|
|
|
/*intr.h*/ 0 +
|
/*intr.h*/ 0 +
|
|
|
/*io.h*/ (sizeof _IO_Number_of_drivers) +
|
/*io.h*/ (sizeof _IO_Number_of_drivers) +
|
(sizeof _IO_Driver_address_table) +
|
(sizeof _IO_Driver_address_table) +
|
(sizeof _IO_Number_of_devices) +
|
(sizeof _IO_Number_of_devices) +
|
(sizeof _IO_Driver_name_table) +
|
(sizeof _IO_Driver_name_table) +
|
|
|
/*isr.h*/ (sizeof _ISR_Nest_level) +
|
/*isr.h*/ (sizeof _ISR_Nest_level) +
|
(sizeof _ISR_Vector_table) +
|
(sizeof _ISR_Vector_table) +
|
(sizeof _ISR_Signals_to_thread_executing) +
|
(sizeof _ISR_Signals_to_thread_executing) +
|
|
|
/*message.h*/ (sizeof _Message_queue_Information) +
|
/*message.h*/ (sizeof _Message_queue_Information) +
|
|
|
/*modes.h*/ 0 +
|
/*modes.h*/ 0 +
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
/*mp.h*/ 0 +
|
/*mp.h*/ 0 +
|
#endif
|
#endif
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
/*mpci.h*/ (sizeof _MPCI_Remote_blocked_threads) +
|
/*mpci.h*/ (sizeof _MPCI_Remote_blocked_threads) +
|
(sizeof _MPCI_Semaphore) +
|
(sizeof _MPCI_Semaphore) +
|
(sizeof _MPCI_table) +
|
(sizeof _MPCI_table) +
|
(sizeof _MPCI_Receive_server_tcb) +
|
(sizeof _MPCI_Receive_server_tcb) +
|
(sizeof _MPCI_Packet_processors) +
|
(sizeof _MPCI_Packet_processors) +
|
#endif
|
#endif
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
/*mppkt.h*/ 0 +
|
/*mppkt.h*/ 0 +
|
#endif
|
#endif
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
/*mptables.h*/ 0 +
|
/*mptables.h*/ 0 +
|
#endif
|
#endif
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
/*msgmp.h*/ 0 +
|
/*msgmp.h*/ 0 +
|
#endif
|
#endif
|
|
|
/*object.h*/ (sizeof _Objects_Local_node) +
|
/*object.h*/ (sizeof _Objects_Local_node) +
|
(sizeof _Objects_Maximum_nodes) +
|
(sizeof _Objects_Maximum_nodes) +
|
(sizeof _Objects_Information_table) +
|
(sizeof _Objects_Information_table) +
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
/*objectmp.h*/ (sizeof _Objects_MP_Maximum_global_objects) +
|
/*objectmp.h*/ (sizeof _Objects_MP_Maximum_global_objects) +
|
(sizeof _Objects_MP_Inactive_global_objects) +
|
(sizeof _Objects_MP_Inactive_global_objects) +
|
#endif
|
#endif
|
|
|
/*options.h*/ 0 +
|
/*options.h*/ 0 +
|
|
|
/*part.h*/ (sizeof _Partition_Information) +
|
/*part.h*/ (sizeof _Partition_Information) +
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
/*partmp.h*/ 0 +
|
/*partmp.h*/ 0 +
|
#endif
|
#endif
|
|
|
/*priority.h*/ (sizeof _Priority_Major_bit_map) +
|
/*priority.h*/ (sizeof _Priority_Major_bit_map) +
|
(sizeof _Priority_Bit_map) +
|
(sizeof _Priority_Bit_map) +
|
|
|
/*ratemon.h*/ (sizeof _Rate_monotonic_Information) +
|
/*ratemon.h*/ (sizeof _Rate_monotonic_Information) +
|
|
|
/*region.h*/ (sizeof _Region_Information) +
|
/*region.h*/ (sizeof _Region_Information) +
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
/*regionmp.h*/ 0 +
|
/*regionmp.h*/ 0 +
|
#endif
|
#endif
|
|
|
/*rtems.h*/ /* Not applicable */
|
/*rtems.h*/ /* Not applicable */
|
|
|
/*sem.h*/ (sizeof _Semaphore_Information) +
|
/*sem.h*/ (sizeof _Semaphore_Information) +
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
/*semmp.h*/ 0 +
|
/*semmp.h*/ 0 +
|
#endif
|
#endif
|
|
|
/*signal.h*/ 0 +
|
/*signal.h*/ 0 +
|
|
|
/*signalmp.h*/ 0 +
|
/*signalmp.h*/ 0 +
|
|
|
/*stack.h*/ 0 +
|
/*stack.h*/ 0 +
|
|
|
/*states.h*/ 0 +
|
/*states.h*/ 0 +
|
|
|
/*status.h*/ 0 +
|
/*status.h*/ 0 +
|
|
|
/*sysstate.h*/ (sizeof _System_state_Is_multiprocessing) +
|
/*sysstate.h*/ (sizeof _System_state_Is_multiprocessing) +
|
(sizeof _System_state_Current) +
|
(sizeof _System_state_Current) +
|
|
|
/*system.h*/ (sizeof _CPU_Table) +
|
/*system.h*/ (sizeof _CPU_Table) +
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
/*taskmp.h*/ 0 +
|
/*taskmp.h*/ 0 +
|
#endif
|
#endif
|
|
|
/*tasks.h*/ (sizeof _RTEMS_tasks_Information) +
|
/*tasks.h*/ (sizeof _RTEMS_tasks_Information) +
|
(sizeof _RTEMS_tasks_User_initialization_tasks) +
|
(sizeof _RTEMS_tasks_User_initialization_tasks) +
|
(sizeof _RTEMS_tasks_Number_of_initialization_tasks) +
|
(sizeof _RTEMS_tasks_Number_of_initialization_tasks) +
|
|
|
/*thread.h*/ (sizeof _Thread_BSP_context) +
|
/*thread.h*/ (sizeof _Thread_BSP_context) +
|
(sizeof _Thread_Dispatch_disable_level) +
|
(sizeof _Thread_Dispatch_disable_level) +
|
(sizeof _Thread_Do_post_task_switch_extension) +
|
(sizeof _Thread_Do_post_task_switch_extension) +
|
(sizeof _Thread_Maximum_extensions) +
|
(sizeof _Thread_Maximum_extensions) +
|
(sizeof _Thread_Ticks_per_timeslice) +
|
(sizeof _Thread_Ticks_per_timeslice) +
|
(sizeof _Thread_Ready_chain) +
|
(sizeof _Thread_Ready_chain) +
|
(sizeof _Thread_Executing) +
|
(sizeof _Thread_Executing) +
|
(sizeof _Thread_Heir) +
|
(sizeof _Thread_Heir) +
|
(sizeof _Thread_Allocated_fp) +
|
(sizeof _Thread_Allocated_fp) +
|
(sizeof _Thread_Internal_information) +
|
(sizeof _Thread_Internal_information) +
|
(sizeof _Thread_Idle) +
|
(sizeof _Thread_Idle) +
|
|
|
#if defined(RTEMS_MULTIPROCESSING)
|
#if defined(RTEMS_MULTIPROCESSING)
|
/*threadmp.h*/ (sizeof _Thread_MP_Receive) +
|
/*threadmp.h*/ (sizeof _Thread_MP_Receive) +
|
(sizeof _Thread_MP_Active_proxies) +
|
(sizeof _Thread_MP_Active_proxies) +
|
(sizeof _Thread_MP_Inactive_proxies) +
|
(sizeof _Thread_MP_Inactive_proxies) +
|
#endif
|
#endif
|
|
|
/*threadq.h*/ (sizeof _Thread_queue_Extract_table) +
|
/*threadq.h*/ (sizeof _Thread_queue_Extract_table) +
|
|
|
/*timer.h*/ (sizeof _Timer_Information) +
|
/*timer.h*/ (sizeof _Timer_Information) +
|
|
|
/*tod.h*/ (sizeof _TOD_Current) +
|
/*tod.h*/ (sizeof _TOD_Current) +
|
(sizeof _TOD_Seconds_since_epoch) +
|
(sizeof _TOD_Seconds_since_epoch) +
|
(sizeof _TOD_Microseconds_per_tick) +
|
(sizeof _TOD_Microseconds_per_tick) +
|
(sizeof _TOD_Ticks_per_second) +
|
(sizeof _TOD_Ticks_per_second) +
|
(sizeof _TOD_Seconds_watchdog) +
|
(sizeof _TOD_Seconds_watchdog) +
|
|
|
/*tqdata.h*/ 0 +
|
/*tqdata.h*/ 0 +
|
|
|
/*types.h*/ 0 +
|
/*types.h*/ 0 +
|
|
|
/*userext.h*/ (sizeof _User_extensions_List) +
|
/*userext.h*/ (sizeof _User_extensions_List) +
|
|
|
/*watchdog.h*/ (sizeof _Watchdog_Sync_level) +
|
/*watchdog.h*/ (sizeof _Watchdog_Sync_level) +
|
(sizeof _Watchdog_Sync_count) +
|
(sizeof _Watchdog_Sync_count) +
|
(sizeof _Watchdog_Ticks_since_boot) +
|
(sizeof _Watchdog_Ticks_since_boot) +
|
(sizeof _Watchdog_Ticks_chain) +
|
(sizeof _Watchdog_Ticks_chain) +
|
(sizeof _Watchdog_Seconds_chain) +
|
(sizeof _Watchdog_Seconds_chain) +
|
|
|
/*wkspace.h*/ (sizeof _Workspace_Area);
|
/*wkspace.h*/ (sizeof _Workspace_Area);
|
|
|
uninitialized = 0;
|
uninitialized = 0;
|
|
|
#ifndef unix /* make sure this is not a native compile */
|
#ifndef unix /* make sure this is not a native compile */
|
|
|
#ifdef __i386__
|
#ifdef __i386__
|
|
|
/* cpu.h */
|
/* cpu.h */
|
uninitialized += (sizeof _CPU_Null_fp_context) +
|
uninitialized += (sizeof _CPU_Null_fp_context) +
|
(sizeof _CPU_Interrupt_stack_low) +
|
(sizeof _CPU_Interrupt_stack_low) +
|
(sizeof _CPU_Interrupt_stack_high);
|
(sizeof _CPU_Interrupt_stack_high);
|
|
|
#endif
|
#endif
|
|
|
#ifdef __i960__
|
#ifdef __i960__
|
|
|
/* cpu.h */
|
/* cpu.h */
|
uninitialized += (sizeof _CPU_Interrupt_stack_low) +
|
uninitialized += (sizeof _CPU_Interrupt_stack_low) +
|
(sizeof _CPU_Interrupt_stack_high);
|
(sizeof _CPU_Interrupt_stack_high);
|
|
|
#endif
|
#endif
|
|
|
#ifdef __hppa__
|
#ifdef __hppa__
|
|
|
/* cpu.h */
|
/* cpu.h */
|
uninitialized += (sizeof _CPU_Null_fp_context) +
|
uninitialized += (sizeof _CPU_Null_fp_context) +
|
#ifndef RTEMS_UNIX
|
#ifndef RTEMS_UNIX
|
(sizeof _CPU_Default_gr27) +
|
(sizeof _CPU_Default_gr27) +
|
#endif
|
#endif
|
(sizeof _CPU_Interrupt_stack_low) +
|
(sizeof _CPU_Interrupt_stack_low) +
|
(sizeof _CPU_Interrupt_stack_high);
|
(sizeof _CPU_Interrupt_stack_high);
|
#endif
|
#endif
|
|
|
#ifdef __mc68000__
|
#ifdef __mc68000__
|
|
|
/* cpu.h */
|
/* cpu.h */
|
uninitialized += (sizeof _CPU_Interrupt_stack_low) +
|
uninitialized += (sizeof _CPU_Interrupt_stack_low) +
|
(sizeof _CPU_Interrupt_stack_high);
|
(sizeof _CPU_Interrupt_stack_high);
|
|
|
#endif
|
#endif
|
|
|
#ifdef __sparc__
|
#ifdef __sparc__
|
|
|
/* cpu.h */
|
/* cpu.h */
|
uninitialized += (sizeof _CPU_Interrupt_stack_low) +
|
uninitialized += (sizeof _CPU_Interrupt_stack_low) +
|
(sizeof _CPU_Interrupt_stack_high) +
|
(sizeof _CPU_Interrupt_stack_high) +
|
(sizeof _CPU_Null_fp_context);
|
(sizeof _CPU_Null_fp_context);
|
|
|
#ifndef NO_TABLE_MOVE
|
#ifndef NO_TABLE_MOVE
|
uninitialized += (sizeof _CPU_Trap_Table_area);
|
uninitialized += (sizeof _CPU_Trap_Table_area);
|
#endif
|
#endif
|
|
|
#ifdef erc32
|
#ifdef erc32
|
uninitialized += (sizeof _ERC32_MEC_Timer_Control_Mirror);
|
uninitialized += (sizeof _ERC32_MEC_Timer_Control_Mirror);
|
#endif
|
#endif
|
|
|
|
|
#endif
|
#endif
|
|
|
|
|
#ifdef no_cpu
|
#ifdef no_cpu
|
|
|
/* cpu.h */
|
/* cpu.h */
|
uninitialized += (sizeof _CPU_Null_fp_context) +
|
uninitialized += (sizeof _CPU_Null_fp_context) +
|
(sizeof _CPU_Interrupt_stack_low) +
|
(sizeof _CPU_Interrupt_stack_low) +
|
(sizeof _CPU_Interrupt_stack_high) +
|
(sizeof _CPU_Interrupt_stack_high) +
|
(sizeof _CPU_Thread_dispatch_pointer);
|
(sizeof _CPU_Thread_dispatch_pointer);
|
|
|
#endif
|
#endif
|
|
|
#ifdef __PPC__
|
#ifdef __PPC__
|
|
|
/* cpu.h */
|
/* cpu.h */
|
uninitialized += (sizeof _CPU_Interrupt_stack_low) +
|
uninitialized += (sizeof _CPU_Interrupt_stack_low) +
|
(sizeof _CPU_Interrupt_stack_high) +
|
(sizeof _CPU_Interrupt_stack_high) +
|
(sizeof _CPU_IRQ_info);
|
(sizeof _CPU_IRQ_info);
|
|
|
#endif
|
#endif
|
#endif /* !unix */
|
#endif /* !unix */
|
|
|
initialized +=
|
initialized +=
|
/*copyrt.h*/ (strlen(_Copyright_Notice)+1) +
|
/*copyrt.h*/ (strlen(_Copyright_Notice)+1) +
|
|
|
/*sptables.h*/ (sizeof _Initialization_Default_multiprocessing_table) +
|
/*sptables.h*/ (sizeof _Initialization_Default_multiprocessing_table) +
|
(strlen(_RTEMS_version)+1) +
|
(strlen(_RTEMS_version)+1) +
|
(sizeof _Entry_points) +
|
(sizeof _Entry_points) +
|
|
|
|
|
/*tod.h*/ (sizeof _TOD_Days_per_month) +
|
/*tod.h*/ (sizeof _TOD_Days_per_month) +
|
(sizeof _TOD_Days_to_date) +
|
(sizeof _TOD_Days_to_date) +
|
(sizeof _TOD_Days_since_last_leap_year);
|
(sizeof _TOD_Days_since_last_leap_year);
|
|
|
#ifndef unix /* make sure this is not native */
|
#ifndef unix /* make sure this is not native */
|
#ifdef __sparc__
|
#ifdef __sparc__
|
|
|
initialized += (sizeof _CPU_Trap_slot_template);
|
initialized += (sizeof _CPU_Trap_slot_template);
|
|
|
#endif
|
#endif
|
#endif /* !unix */
|
#endif /* !unix */
|
|
|
puts( "" );
|
puts( "" );
|
|
|
if ( mode == 0 ) help_size();
|
if ( mode == 0 ) help_size();
|
else print_formula();
|
else print_formula();
|
|
|
printf( "\n" );
|
printf( "\n" );
|
printf( "RTEMS uninitialized data consumes %d bytes\n", uninitialized );
|
printf( "RTEMS uninitialized data consumes %d bytes\n", uninitialized );
|
printf( "RTEMS intialized data consumes %d bytes\n", initialized );
|
printf( "RTEMS intialized data consumes %d bytes\n", initialized );
|
|
|
}
|
}
|
|
|
void help_size()
|
void help_size()
|
{
|
{
|
int c = '\0';
|
int c = '\0';
|
int break_loop;
|
int break_loop;
|
int total_size;
|
int total_size;
|
int task_stacks;
|
int task_stacks;
|
int interrupt_stack;
|
int interrupt_stack;
|
int maximum_tasks, size_tasks;
|
int maximum_tasks, size_tasks;
|
int maximum_sems, size_sems;
|
int maximum_sems, size_sems;
|
int maximum_timers, size_timers;
|
int maximum_timers, size_timers;
|
int maximum_msgqs, size_msgqs;
|
int maximum_msgqs, size_msgqs;
|
int maximum_msgs, size_msgs_overhead;
|
int maximum_msgs, size_msgs_overhead;
|
int maximum_regns, size_regns;
|
int maximum_regns, size_regns;
|
int maximum_parts, size_parts;
|
int maximum_parts, size_parts;
|
int maximum_ports, size_ports;
|
int maximum_ports, size_ports;
|
int maximum_periods, size_periods;
|
int maximum_periods, size_periods;
|
int maximum_extensions, size_extensions;
|
int maximum_extensions, size_extensions;
|
int maximum_drvs, size_drvs;
|
int maximum_drvs, size_drvs;
|
int maximum_fps, size_fps;
|
int maximum_fps, size_fps;
|
int maximum_nodes, size_nodes;
|
int maximum_nodes, size_nodes;
|
int maximum_gobjs, size_gobjs;
|
int maximum_gobjs, size_gobjs;
|
int maximum_proxies, size_proxies;
|
int maximum_proxies, size_proxies;
|
|
|
total_size = sys_req; /* Fixed Overhead */
|
total_size = sys_req; /* Fixed Overhead */
|
printf( "What is maximum_tasks? " );
|
printf( "What is maximum_tasks? " );
|
maximum_tasks = getint();
|
maximum_tasks = getint();
|
size_tasks = PER_TASK * maximum_tasks;
|
size_tasks = PER_TASK * maximum_tasks;
|
total_size += size_tasks;
|
total_size += size_tasks;
|
|
|
printf( "What is maximum_semaphores? " );
|
printf( "What is maximum_semaphores? " );
|
maximum_sems = getint();
|
maximum_sems = getint();
|
size_sems = PER_SEMAPHORE * maximum_sems;
|
size_sems = PER_SEMAPHORE * maximum_sems;
|
total_size += size_sems;
|
total_size += size_sems;
|
|
|
printf( "What is maximum_timers? " );
|
printf( "What is maximum_timers? " );
|
maximum_timers = getint();
|
maximum_timers = getint();
|
size_timers = PER_TIMER * maximum_timers;
|
size_timers = PER_TIMER * maximum_timers;
|
total_size += size_timers;
|
total_size += size_timers;
|
|
|
printf( "What is maximum_message_queues? " );
|
printf( "What is maximum_message_queues? " );
|
maximum_msgqs = getint();
|
maximum_msgqs = getint();
|
size_msgqs = PER_MSGQ * maximum_msgqs;
|
size_msgqs = PER_MSGQ * maximum_msgqs;
|
total_size += size_msgqs;
|
total_size += size_msgqs;
|
|
|
printf( "What is maximum_messages? XXXX " );
|
printf( "What is maximum_messages? XXXX " );
|
maximum_msgs = getint();
|
maximum_msgs = getint();
|
size_msgs_overhead = 0;
|
size_msgs_overhead = 0;
|
total_size += size_msgs_overhead;
|
total_size += size_msgs_overhead;
|
|
|
printf( "What is maximum_regions? " );
|
printf( "What is maximum_regions? " );
|
maximum_regns = getint();
|
maximum_regns = getint();
|
size_regns = PER_REGN * maximum_regns;
|
size_regns = PER_REGN * maximum_regns;
|
total_size += size_regns;
|
total_size += size_regns;
|
|
|
printf( "What is maximum_partitions? " );
|
printf( "What is maximum_partitions? " );
|
maximum_parts = getint();
|
maximum_parts = getint();
|
size_parts = PER_PART * maximum_parts;
|
size_parts = PER_PART * maximum_parts;
|
total_size += size_parts;
|
total_size += size_parts;
|
|
|
printf( "What is maximum_ports? " );
|
printf( "What is maximum_ports? " );
|
maximum_ports = getint();
|
maximum_ports = getint();
|
size_ports = PER_PORT * maximum_ports;
|
size_ports = PER_PORT * maximum_ports;
|
total_size += size_ports;
|
total_size += size_ports;
|
|
|
printf( "What is maximum_periods? " );
|
printf( "What is maximum_periods? " );
|
maximum_periods = getint();
|
maximum_periods = getint();
|
size_periods = PER_PORT * maximum_periods;
|
size_periods = PER_PORT * maximum_periods;
|
total_size += size_periods;
|
total_size += size_periods;
|
|
|
printf( "What is maximum_extensions? " );
|
printf( "What is maximum_extensions? " );
|
maximum_extensions = getint();
|
maximum_extensions = getint();
|
size_extensions = PER_EXTENSION * maximum_extensions;
|
size_extensions = PER_EXTENSION * maximum_extensions;
|
total_size += size_extensions;
|
total_size += size_extensions;
|
|
|
printf( "What is number_of_device_drivers? " );
|
printf( "What is number_of_device_drivers? " );
|
maximum_drvs = getint();
|
maximum_drvs = getint();
|
size_drvs = PER_DRV * maximum_drvs;
|
size_drvs = PER_DRV * maximum_drvs;
|
total_size += size_drvs;
|
total_size += size_drvs;
|
|
|
printf( "What will be total stack requirement for all tasks? " );
|
printf( "What will be total stack requirement for all tasks? " );
|
task_stacks = getint();
|
task_stacks = getint();
|
total_size += task_stacks;
|
total_size += task_stacks;
|
|
|
printf( "What is the size of the interrupt stack? " );
|
printf( "What is the size of the interrupt stack? " );
|
interrupt_stack = getint();
|
interrupt_stack = getint();
|
total_size += interrupt_stack;
|
total_size += interrupt_stack;
|
|
|
printf( "How many tasks will be created with the FP flag? " );
|
printf( "How many tasks will be created with the FP flag? " );
|
maximum_fps = getint();
|
maximum_fps = getint();
|
size_fps = PER_FPTASK * maximum_fps;
|
size_fps = PER_FPTASK * maximum_fps;
|
total_size += size_fps;
|
total_size += size_fps;
|
|
|
printf( "Is this a single processor system? " );
|
printf( "Is this a single processor system? " );
|
for ( break_loop=0 ; !break_loop; c = getchar() ) {
|
for ( break_loop=0 ; !break_loop; c = getchar() ) {
|
switch ( c ) {
|
switch ( c ) {
|
case 'Y': case 'y':
|
case 'Y': case 'y':
|
case 'N': case 'n':
|
case 'N': case 'n':
|
break_loop = 1;
|
break_loop = 1;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
printf( "%c\n", c );
|
printf( "%c\n", c );
|
if ( c == 'n' || c == 'N' ) {
|
if ( c == 'n' || c == 'N' ) {
|
printf( "What is maximum_nodes? " );
|
printf( "What is maximum_nodes? " );
|
maximum_nodes = getint();
|
maximum_nodes = getint();
|
size_nodes = PER_NODE * maximum_nodes;
|
size_nodes = PER_NODE * maximum_nodes;
|
total_size += size_nodes;
|
total_size += size_nodes;
|
printf( "What is maximum_global_objects? " );
|
printf( "What is maximum_global_objects? " );
|
maximum_gobjs = getint();
|
maximum_gobjs = getint();
|
size_gobjs = PER_GOBJECT * maximum_gobjs;
|
size_gobjs = PER_GOBJECT * maximum_gobjs;
|
total_size += size_gobjs;
|
total_size += size_gobjs;
|
printf( "What is maximum_proxies? " );
|
printf( "What is maximum_proxies? " );
|
maximum_proxies = getint();
|
maximum_proxies = getint();
|
size_proxies = PER_PROXY * maximum_proxies;
|
size_proxies = PER_PROXY * maximum_proxies;
|
total_size += size_proxies;
|
total_size += size_proxies;
|
} else {
|
} else {
|
maximum_nodes = 0;
|
maximum_nodes = 0;
|
size_nodes = PER_NODE * 0;
|
size_nodes = PER_NODE * 0;
|
maximum_gobjs = 0;
|
maximum_gobjs = 0;
|
size_gobjs = PER_GOBJECT * 0;
|
size_gobjs = PER_GOBJECT * 0;
|
maximum_proxies = 0;
|
maximum_proxies = 0;
|
size_proxies = PER_PROXY * 0;
|
size_proxies = PER_PROXY * 0;
|
}
|
}
|
|
|
printf( "\n\n" );
|
printf( "\n\n" );
|
printf( " ************** EXECUTIVE WORK SPACE REQUIRED **************\n" );
|
printf( " ************** EXECUTIVE WORK SPACE REQUIRED **************\n" );
|
printf( " Tasks - %03d * %03ld = %ld\n",
|
printf( " Tasks - %03d * %03ld = %ld\n",
|
maximum_tasks, PER_TASK, (long) size_tasks );
|
maximum_tasks, PER_TASK, (long) size_tasks );
|
printf( " Semaphores - %03d * %03ld = %ld\n",
|
printf( " Semaphores - %03d * %03ld = %ld\n",
|
maximum_sems, PER_SEMAPHORE, (long) size_sems );
|
maximum_sems, PER_SEMAPHORE, (long) size_sems );
|
printf( " Timers - %03d * %03ld = %ld\n",
|
printf( " Timers - %03d * %03ld = %ld\n",
|
maximum_timers, PER_TIMER, (long) size_timers );
|
maximum_timers, PER_TIMER, (long) size_timers );
|
printf( " Msg Queues - %03d * %03ld = %ld\n",
|
printf( " Msg Queues - %03d * %03ld = %ld\n",
|
maximum_msgqs, PER_MSGQ, (long) size_msgqs );
|
maximum_msgqs, PER_MSGQ, (long) size_msgqs );
|
printf( " Messages Overhead - %03d * %03d = %ld\n",
|
printf( " Messages Overhead - %03d * %03d = %ld\n",
|
maximum_msgs, 0 /* PER_MSG_OVERHEAD */, (long) size_msgs_overhead );
|
maximum_msgs, 0 /* PER_MSG_OVERHEAD */, (long) size_msgs_overhead );
|
printf( " Regions - %03d * %03ld = %ld\n",
|
printf( " Regions - %03d * %03ld = %ld\n",
|
maximum_regns, PER_REGN, (long) size_regns);
|
maximum_regns, PER_REGN, (long) size_regns);
|
printf( " Partitions - %03d * %03ld = %ld\n",
|
printf( " Partitions - %03d * %03ld = %ld\n",
|
maximum_parts, PER_PART, (long) size_parts );
|
maximum_parts, PER_PART, (long) size_parts );
|
printf( " Periods - %03d * %03ld = %ld\n",
|
printf( " Periods - %03d * %03ld = %ld\n",
|
maximum_periods, PER_PERIOD, (long) size_periods );
|
maximum_periods, PER_PERIOD, (long) size_periods );
|
printf( " Extensions - %03d * %03ld = %ld\n",
|
printf( " Extensions - %03d * %03ld = %ld\n",
|
maximum_extensions, PER_EXTENSION, (long) size_extensions );
|
maximum_extensions, PER_EXTENSION, (long) size_extensions );
|
printf( " Device Drivers - %03d * %03ld = %ld\n",
|
printf( " Device Drivers - %03d * %03ld = %ld\n",
|
maximum_drvs, PER_DRV, (long) size_drvs );
|
maximum_drvs, PER_DRV, (long) size_drvs );
|
|
|
printf( " System Requirements - %04d = %d\n",
|
printf( " System Requirements - %04d = %d\n",
|
sys_req, sys_req );
|
sys_req, sys_req );
|
|
|
printf( " Floating Point Tasks - %03d * %03ld = %ld\n",
|
printf( " Floating Point Tasks - %03d * %03ld = %ld\n",
|
maximum_fps, PER_FPTASK, (long) size_fps );
|
maximum_fps, PER_FPTASK, (long) size_fps );
|
printf( " Application Task Stacks - = %d\n",
|
printf( " Application Task Stacks - = %d\n",
|
task_stacks );
|
task_stacks );
|
printf( " Interrupt Stacks - = %d\n",
|
printf( " Interrupt Stacks - = %d\n",
|
task_stacks );
|
task_stacks );
|
printf( " \n" );
|
printf( " \n" );
|
printf( " Global object tables - %03d * %03ld = %ld\n",
|
printf( " Global object tables - %03d * %03ld = %ld\n",
|
maximum_nodes, PER_NODE, (long) size_nodes );
|
maximum_nodes, PER_NODE, (long) size_nodes );
|
printf( " Global objects - %03d * %03ld = %ld\n",
|
printf( " Global objects - %03d * %03ld = %ld\n",
|
maximum_gobjs, PER_GOBJECT, (long) size_gobjs );
|
maximum_gobjs, PER_GOBJECT, (long) size_gobjs );
|
printf( " Proxies - %03d * %03ld = %ld\n",
|
printf( " Proxies - %03d * %03ld = %ld\n",
|
maximum_proxies, PER_PROXY, (long) size_proxies );
|
maximum_proxies, PER_PROXY, (long) size_proxies );
|
printf( "\n\n" );
|
printf( "\n\n" );
|
printf( " TOTAL = %d bytes\n",
|
printf( " TOTAL = %d bytes\n",
|
total_size );
|
total_size );
|
}
|
}
|
|
|
void print_formula()
|
void print_formula()
|
{
|
{
|
printf( " ************** EXECUTIVE WORK SPACE FORMULA **************\n" );
|
printf( " ************** EXECUTIVE WORK SPACE FORMULA **************\n" );
|
printf( " Tasks - maximum_tasks * %ld\n", PER_TASK );
|
printf( " Tasks - maximum_tasks * %ld\n", PER_TASK );
|
printf( " Timers - maximum_timers * %ld\n", PER_TIMER );
|
printf( " Timers - maximum_timers * %ld\n", PER_TIMER );
|
printf( " Semaphores - maximum_semaphores * %ld\n", PER_SEMAPHORE);
|
printf( " Semaphores - maximum_semaphores * %ld\n", PER_SEMAPHORE);
|
printf( " Message Queues - maximum_message_queues * %ld\n", PER_MSGQ );
|
printf( " Message Queues - maximum_message_queues * %ld\n", PER_MSGQ );
|
printf( " Messages -\n");
|
printf( " Messages -\n");
|
printf( " Regions - maximum_regions * %ld\n", PER_REGN );
|
printf( " Regions - maximum_regions * %ld\n", PER_REGN );
|
printf( " Partitions - maximum_partitions * %ld\n", PER_PART );
|
printf( " Partitions - maximum_partitions * %ld\n", PER_PART );
|
printf( " Ports - maximum_ports * %ld\n", PER_PORT );
|
printf( " Ports - maximum_ports * %ld\n", PER_PORT );
|
printf( " Periods - maximum_periods * %ld\n", PER_PORT );
|
printf( " Periods - maximum_periods * %ld\n", PER_PORT );
|
printf( " Extensions - maximum_extensions * %ld\n", PER_EXTENSION );
|
printf( " Extensions - maximum_extensions * %ld\n", PER_EXTENSION );
|
printf( " Device Drivers - number_of_device_drivers * %ld\n", PER_DRV);
|
printf( " Device Drivers - number_of_device_drivers * %ld\n", PER_DRV);
|
printf( " System Requirements - %d\n", sys_req );
|
printf( " System Requirements - %d\n", sys_req );
|
printf( " Floating Point Tasks - FPMASK Tasks * %ld\n", PER_FPTASK );
|
printf( " Floating Point Tasks - FPMASK Tasks * %ld\n", PER_FPTASK );
|
printf( " User's Tasks' Stacks -\n" );
|
printf( " User's Tasks' Stacks -\n" );
|
printf( " Interrupt Stack -\n" );
|
printf( " Interrupt Stack -\n" );
|
printf( " \n" );
|
printf( " \n" );
|
printf( " Global object tables - maximum_nodes * %ld\n", PER_NODE );
|
printf( " Global object tables - maximum_nodes * %ld\n", PER_NODE );
|
printf( " Global objects - maximum_global_objects * %ld\n", PER_GOBJECT );
|
printf( " Global objects - maximum_global_objects * %ld\n", PER_GOBJECT );
|
printf( " Proxies - maximum_proxies * %ld\n", PER_PROXY );
|
printf( " Proxies - maximum_proxies * %ld\n", PER_PROXY );
|
}
|
}
|
|
|
