source: rtems/testsuites/sptests/spsize/size.c @ 7aa4671

4.104.114.84.9
Last change on this file since 7aa4671 was 7aa4671, checked in by Joel Sherrill <joel.sherrill@…>, on Jun 5, 1996 at 9:12:06 PM

added cpu_time_budget field to Thread_Control and removed the global variable
_Thread_Ticks_remaining_in_timeslice.

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