SYNOPSIS
#include <driver_info.h>
mixed driver_info(int what)
DESCRIPTION
Returns some internal information about the driver.
The argument <what> determines which information is returned.
It can be either a configuration option as given to
configure_driver() or one of the following options:
Driver Environment:
<what> == DI_BOOT_TIME:
The time() when the driver was started.
LPC Runtime status:
<what> == DI_CURRENT_RUNTIME_LIMITS:
Return an array with the current runtime limits.
The entries in the returned array are:
int[LIMIT_EVAL]: the max number of eval costs
int[LIMIT_ARRAY]: the max number of array entries
int[LIMIT_MAPPING_SIZE]: the max number of mapping values
int[LIMIT_MAPPING_KEYS]: the max number of mapping entries
(LIMIT_MAPPING is an alias for LIMIT_MAPPING_KEYS)
int[LIMIT_BYTE]: the max number of bytes handled with
one read_bytes()/write_bytes() call.
int[LIMIT_FILE]: the max number of bytes handled with
one read_file()/write_file() call.
int[LIMIT_CALLOUTS]: the number of callouts at one time.
int[LIMIT_COST]: how to account the current cost.
int[LIMIT_MEMROY]: the max. number of bytes which can be
_additionally_ allocated/used
_per top-level execution thread_
For all limits except LIMIT_COST a limit of '0' aka LIMIT_UNLIMITED
means 'no limit'.
The value for LIMIT_COST has these meanings:
value > 0: the execution will cost minimum(<value>, actual cost) .
value = 0: if the current LIMIT_EVAL is larger than the calling
LIMIT_EVAL, the evaluation will cost only 10; otherwise
the full cost will be accounted.
value < 0: (-value)% of the current evaluation cost will be
accounted; -100 obviously means 'full cost'.
<what> == DI_EVAL_NUMBER:
Return the current evaluation number.
The number is incremented for each top-level call. Top-level
calls are initiated by the driver, usually in reaction to an
external event:
- commands (added by add_action)
- heart_beat, reset, clean_up
- calls from call_out or input_to
- master applies triggered by external events
- calls of driver hooks in reaction to external events
- send_erq callbacks
- logon in interactives
The number can be used to detect cases where the same code is
executed twice in the same top level evaluation (say, heart_beat),
and also for time stamps for ordering some events.
Please note that the counter may overflow, especially on 32 bit
systems. As a result, it can also be negative.
Network configuration:
<what> == DI_MUD_PORTS:
Returns an array with all open ports, which the driver
listens for player connections on.
<what> == DI_UDP_PORT:
Returns the port number of the UDP socket.
Memory management:
<what> == DI_MEMORY_RESERVE_USER:
Current size of the user memory reserve.
The user memory reserve is allocated at startup and is used
when the driver runs out of memory.
<what> == DI_MEMORY_RESERVE_MASTER:
Current size of the master memory reserve.
The master memory reserve is allocated at startup and is used
when the driver runs out of memory while executing master
code.
<what> == DI_MEMORY_RESERVE_SYSTEM:
Current size of the system memory reserve.
The system memory reserve is allocated at startup and is used
when the driver runs out of memory while executing internal
operations.
Traces:
<what> == DI_TRACE_CURRENT:
Returns the current stack trace in array form.
If the array has more than one entries, the first entry is 0 or
the name of the object with the heartbeat which started the
current thread; all following entries describe the call stack
starting with the topmost function called.
All call entries are arrays themselves with the following elements:
int[TRACE_TYPE]: The type of the call frame:
TRACE_TYPE_SYMBOL (0): a function symbol (shouldn't happen).
TRACE_TYPE_SEFUN (1): a simul-efun.
TRACE_TYPE_EFUN (2): an efun closure.
TRACE_TYPE_LAMBDA (3): a lambda closure.
TRACE_TYPE_LFUN (4): a normal lfun.
mixed[TRACE_NAME]: The 'name' of the called frame:
_TYPE_EFUN: either the name of the efun, or the code of
the instruction for operator closures
_TYPE_LAMBDA: the numeric lambda identifier.
_TYPE_LFUN: the name of the lfun.
string[TRACE_PROGRAM]: The (file)name of the program holding
the code.
string[TRACE_OBJECT]: The name of the object for which the code
was executed.
int[TRACE_LOC]:
_TYPE_LAMBDA: current program offset from the start of the
closure code.
_TYPE_LFUN: the line number.
<what> == DI_TRACE_CURRENT_DEPTH:
Return the current number of frames on the control stack
(recursion depth).
<what> == DI_TRACE_CURRENT_AS_STRING:
Returns the current stack trace as a string.
<what> == DI_TRACE_LAST_ERROR:
Returns the stack trace of the last error in array form
(same format as DI_TRACE_CURRENT). Stack traces of errors
before the last GC might not be available anymore.
<what> == DI_TRACE_LAST_ERROR_AS_STRING:
Returns the stack trace of the last error as a string.
<what> == DI_TRACE_LAST_UNCAUGHT_ERROR:
Returns the stack trace of the last uncaught error in array form
(same format as DI_TRACE_CURRENT). Stack traces of errors
before the last GC might not be available anymore.
<what> == DI_TRACE_LAST_UNCAUGHT_ERROR_AS_STRING:
Returns the stack trace of the last uncaught error as a string.
LPC Runtime statistics:
<what> == DI_NUM_FUNCTION_NAME_CALLS:
Number of function calls by name (like call_other).
<what> == DI_NUM_FUNCTION_NAME_CALL_HITS:
Function calls by name are cached (to accelerate
lookup of the corresponding program code).
This returns the number of cache hits.
<what> == DI_NUM_FUNCTION_NAME_CALL_MISSES:
The number of function call cache misses.
<what> == DI_NUM_OBJECTS_LAST_PROCESSED:
Number of listed objects processed in the last backend cycle.
<what> == DI_NUM_HEARTBEAT_TOTAL_CYCLES:
Total number of heart_beats cycles so far.
<what> == DI_NUM_HEARTBEAT_ACTIVE_CYCLES:
Number of active heart_beat cycles executed so far
(ie. cycles in which at least one heart_beat() function
was called).
<what> == DI_NUM_HEARTBEATS_LAST_PROCESSED:
Number of heart_beats calls in the last backend cycle
<what> == DI_NUM_STRING_TABLE_STRINGS_ADDED:
Number of distinct strings added to the string table so far.
<what> == DI_NUM_STRING_TABLE_STRINGS_REMOVED:
Number of distinct strings removed from the string table so far.
<what> == DI_NUM_STRING_TABLE_LOOKUPS_BY_VALUE:
Number of string searches by value.
<what> == DI_NUM_STRING_TABLE_LOOKUPS_BY_INDEX:
Number of string searches by address.
<what> == DI_NUM_STRING_TABLE_LOOKUP_STEPS_BY_VALUE:
Number of lookup steps needed for string searches by value.
<what> == DI_NUM_STRING_TABLE_LOOKUP_STEPS_BY_INDEX:
Number of lookup steps needed for string searches by address.
<what> == DI_NUM_STRING_TABLE_HITS_BY_VALUE:
Number of successful lookups of strings by value.
<what> == DI_NUM_STRING_TABLE_HITS_BY_INDEX:
Number of successful lookups of strings by address.
<what> == DI_NUM_STRING_TABLE_COLLISIONS:
Number of distinct strings added to an existing hash chain so far.
<what> == DI_NUM_REGEX_LOOKUPS:
Number of requests for new regexps.
<what> == DI_NUM_REGEX_LOOKUP_HITS:
Number of requested regexps found in the table.
<what> == DI_NUM_REGEX_LOOKUP_MISSES:
Number of requested regexps not found in the table.
<what> == DI_NUM_REGEX_LOOKUP_COLLISIONS:
Number of requested new regexps which collided with a cached one.
Network statistics:
<what> == DI_NUM_MESSAGES_OUT:
Number of messages sent to a player.
<what> == DI_NUM_PACKETS_OUT:
Number of packets sent to a player.
<what> == DI_NUM_PACKETS_IN:
Number of packets received from a player.
<what> == DI_SIZE_PACKETS_OUT:
Number of bytes sent to a player.
<what> == DI_SIZE_PACKETS_IN:
Number of bytes received from a player.
Load:
<what> == DI_LOAD_AVERAGE_COMMANDS:
A float value that shows the number of executed player commands
per second.
<what> == DI_LOAD_AVERAGE_LINES:
A float value that shows the number of compiled code lines
per second.
<what> == DI_LOAD_AVERAGE_PROCESSED_OBJECTS:
A float value that shows the average number of objects processed
each backend cycle.
<what> == DI_LOAD_AVERAGE_PROCESSED_OBJECTS_RELATIVE:
Average number of objects processed each cycle, expressed
as percentage (0..1.0) of the number of present objects.
<what> == DI_LOAD_AVERAGE_PROCESSED_HEARTBEATS_RELATIVE:
Average number of heart_beats called each cycle, expressed
as fraction (0..1.0) of the number of active heartbeats.
Memory use statistics:
<what> == DI_NUM_ACTIONS:
Number of allocated actions.
<what> == DI_NUM_CALLOUTS:
Number of pending call_outs.
<what> == DI_NUM_HEARTBEATS:
Number of objects with a heartbeat.
<what> == DI_NUM_SHADOWS:
Number of allocated shadows.
<what> == DI_NUM_OBJECTS:
Number of objects.
<what> == DI_NUM_OBJECTS_SWAPPED:
Number of objects that are swapped-out.
<what> == DI_NUM_OBJECTS_IN_LIST:
Number of objects in the object list
(i.e. not destructed objects).
<what> == DI_NUM_OBJECTS_IN_TABLE:
Number of objects in the object table.
<what> == DI_NUM_OBJECTS_DESTRUCTED:
Number of destructed, but still referenced objects.
(Not counting DI_NUM_OBJECTS_NEWLY_DESTRUCTED).
<what> == DI_NUM_OBJECTS_NEWLY_DESTRUCTED:
Number of newly destructed objects (ie. objects destructed
in this execution thread, that will really be destroyed in
the next backend cycle).
<what> == DI_NUM_OBJECT_TABLE_SLOTS:
Number of hash slots provided by the object table.
<what> == DI_NUM_PROGS:
Size occupied by the object table.
<what> == DI_NUM_PROGS_SWAPPED:
Number of swapped-out program blocks
<what> == DI_NUM_PROGS_UNSWAPPED:
Number of programs that were swapped-out, are now swapped-in,
but still have allocated space in the swap file.
<what> == DI_NUM_ARRAYS:
Number of currently existing arrays.
<what> == DI_NUM_MAPPINGS:
Number of currently existing mappings.
<what> == DI_NUM_MAPPINGS_CLEAN:
Number of clean mappings (mappings without a hash part).
<what> == DI_NUM_MAPPINGS_HASH:
Number of hash mappings.
<what> == DI_NUM_MAPPINGS_HYBRID:
Number of hybrid mappings (mappings that have a
condensed and hash part).
<what> == DI_NUM_STRUCTS:
Number of currently existing structs.
<what> == DI_NUM_STRUCT_TYPES:
Number of currently existing struct types.
<what> == DI_NUM_VIRTUAL_STRINGS:
Number of currently existing virtual strings
(identical strings are counted separately).
<what> == DI_NUM_STRINGS:
Number of real strings (identical strings
are counted once).
<what> == DI_NUM_STRINGS_TABLED:
Number of directly tabled strings.
<what> == DI_NUM_STRINGS_UNTABLED:
Number of untabled strings.
<what> == DI_NUM_STRING_TABLE_SLOTS:
Number of hash slots in the string table.
<what> == DI_NUM_STRING_TABLE_SLOTS_USED:
Number of hash chains in the string table.
<what> == DI_NUM_REGEX:
Number of cached regular expressions.
<what> == DI_NUM_REGEX_TABLE_SLOTS:
Number of slots in the regexp cache table.
<what> == DI_NUM_LVALUES
Number of lvalues (values referenced by &var).
<what> == DI_SIZE_ACTIONS:
Total size of allocated actions.
<what> == DI_SIZE_CALLOUTS:
Total size of pending call_outs.
<what> == DI_SIZE_HEARTBEATS:
Total size of the heart_beat list.
<what> == DI_SIZE_SHADOWS:
Total size of allocated shadows.
<what> == DI_SIZE_OBJECTS:
Total size of objects (not counting the size of the values
of their variables).
<what> == DI_SIZE_OBJECTS_SWAPPED:
Total size of swapped-out variable blocks.
<what> == DI_SIZE_OBJECT_TABLE:
Size occupied by the object table.
<what> == DI_SIZE_PROGS:
Total size of all programs.
<what> == DI_SIZE_PROGS_SWAPPED:
Total size of swapped-out program blocks
<what> == DI_SIZE_PROGS_UNSWAPPED:
Total size of unswapped program blocks
<what> == DI_SIZE_ARRAYS:
Total size of all arrays (not counting additional sizes
of array element values).
<what> == DI_SIZE_MAPPINGS:
Total size of all mapping (not counting additional sizes
of contained values).
<what> == DI_SIZE_STRUCTS:
Total size of all structs (not counting additional sizes
of contained values).
<what> == DI_SIZE_STRUCT_TYPES:
Total size of all struct type definitions.
<what> == DI_SIZE_STRINGS:
Total size of all strings.
<what> == DI_SIZE_STRINGS_TABLED:
Total size of all tabled strings.
<what> == DI_SIZE_STRINGS_UNTABLED:
Total size of all untabled strings.
<what> == DI_SIZE_STRING_TABLE:
Size of the string table structure itself.
<what> == DI_SIZE_STRING_OVERHEAD:
Size of the overhead per string (compared to a raw string).
<what> == DI_SIZE_REGEX:
Total size of all cached regular expressions.
<what> == DI_SIZE_BUFFER_FILE:
The size of the memory buffer for file operations.
<what> == DI_SIZE_BUFFER_SWAP:
The size of the memory buffer for the swap file.
Memory swapper statistics:
<what> == DI_NUM_SWAP_BLOCKS:
Number of blocks in the swap file.
<what> == DI_NUM_SWAP_BLOCKS_FREE:
Number of free blocks in the swap file.
<what> == DI_NUM_SWAP_BLOCKS_REUSE_LOOKUPS:
Number of searches for blocks to reuse in the swap file.
<what> == DI_NUM_SWAP_BLOCKS_REUSE_LOOKUP_STEPS:
Total number of lookup steps in searches for blocks
to reuse in the swap file.
<what> == DI_NUM_SWAP_BLOCKS_FREE_LOOKUPS:
Number of searches for blocks to free in the swap file.
<what> == DI_NUM_SWAP_BLOCKS_FREE_LOOKUP_STEPS:
Total number of lookup steps in searches for blocks
to free in the swap file.
<what> == DI_SIZE_SWAP_BLOCKS:
Size of the swap file.
<what> == DI_SIZE_SWAP_BLOCKS_FREE:
Size of free blocks in the swap file.
<what> == DI_SIZE_SWAP_BLOCKS_REUSED:
Total reused space in the swap file.
<what> == DI_SWAP_RECYCLE_PHASE:
True if the swapper is currently recycling free block.
Memory allocator statistics:
<what> == DI_MEMORY_ALLOCATOR_NAME:
The name of the allocator: "sysmalloc", "smalloc", "slaballoc
<what> == DI_NUM_SYS_ALLOCATED_BLOCKS:
Number of memory blocks requested from the operating system.
<what> == DI_NUM_LARGE_BLOCKS_ALLOCATED:
Number of large allocated blocks.
(With smalloc: The large allocated blocks include
the small chunk blocks.)
<what> == DI_NUM_LARGE_BLOCKS_FREE:
Number of large free blocks.
<what> == DI_NUM_LARGE_BLOCKS_WASTE:
Number of unusable large memory fragments.
<what> == DI_NUM_SMALL_BLOCKS_ALLOCATED:
Number of small allocated blocks.
<what> == DI_NUM_SMALL_BLOCKS_FREE:
Number of small free blocks.
<what> == DI_NUM_SMALL_BLOCKS_WASTE:
Number of unusably small memory fragments.
<what> == DI_NUM_SMALL_BLOCK_CHUNKS:
Number of small chunk/slab blocks.
(That are large blocks that are used as a
base for small blocks.)
<what> == DI_NUM_UNMANAGED_BLOCKS:
Number of unmanaged (non-GC-able) allocations.
<what> == DI_NUM_FREE_BLOCKS_AVL_NODES:
Number of AVL nodes used to manage the large free
blocks. This value might go away again.
<what> == DI_SIZE_SYS_ALLOCATED_BLOCKS:
Total size of memory requested from the operating system.
<what> == DI_SIZE_LARGE_BLOCKS_ALLOCATED:
Total size of large allocated blocks.
<what> == DI_SIZE_LARGE_BLOCKS_FREE:
Total size of large free blocks.
<what> == DI_SIZE_LARGE_BLOCKS_WASTE:
Total size of unusable large memory fragments.
<what> == DI_SIZE_LARGE_BLOCK_OVERHEAD:
The overhead of every large block allocation.
<what> == DI_SIZE_SMALL_BLOCKS_ALLOCATED:
Total size of small allocated blocks.
<what> == DI_SIZE_SMALL_BLOCKS_FREE:
Total size of small free blocks.
<what> == DI_SIZE_SMALL_BLOCKS_WASTE:
Total size of unusably small memory fragments.
<what> == DI_SIZE_SMALL_BLOCK_OVERHEAD:
The overhead of every small block allocation.
<what> == DI_SIZE_SMALL_BLOCK_CHUNKS:
Total size of small chunk/slab blocks.
<what> == DI_SIZE_UNMANAGED_BLOCKS:
Total size of unmanaged (non-GC-able) allocations.
<what> == DI_SIZE_MEMORY_USED:
The amount of memory currently allocated from the allocator.
<what> == DI_SIZE_MEMORY_UNUSED:
The amount of memory allocated from the system, but
not used by the driver.
<what> == DI_SIZE_MEMORY_OVERHEAD:
Amount of memory used for the management of the memory.
<what> == DI_NUM_INCREMENT_SIZE_CALLS:
Number of requests to increase the size of a memory block.
<what> == DI_NUM_INCREMENT_SIZE_CALL_SUCCESSES:
Number of successful requests to increase the
size of a memory block.
<what> == DI_SIZE_INCREMENT_SIZE_CALL_DIFFS:
Total size of additionally allocated memory by
increasing already allocated memory blocks.
<what> == DI_NUM_REPLACEMENT_MALLOC_CALLS:
Number of allocations done through the
clib functions (if supported by the allocator).
<what> == DI_SIZE_REPLACEMENT_MALLOC_CALLS:
Total size of allocations done through the
clib functions (if supported by the allocator).
<what> == DI_NUM_MEMORY_DEFRAGMENTATION_CALLS_FULL:
Total number of requests to defragment all small memory chunks.
<what> == DI_NUM_MEMORY_DEFRAGMENTATION_CALLS_TARGETED:
Total number of requests to defragment small memory chunks
for a desired size.
<what> == DI_NUM_MEMORY_DEFRAGMENTATION_CALL_TARGET_HITS:
Total number of successful requests to defragment small
memory chunks for a desired size.
<what> == DI_NUM_MEMORY_DEFRAGMENTATION_BLOCKS_INSPECTED:
Number of blocks inspected during defragmentations.
<what> == DI_NUM_MEMORY_DEFRAGMENTATION_BLOCKS_MERGED:
Number of blocks merged during defragmentations.
<what> == DI_NUM_MEMORY_DEFRAGMENTATION_BLOCKS_RESULTING:
Number of defragmented blocks (ie. merge results).
<what> == DI_MEMORY_EXTENDED_STATISTICS:
If the driver was compiled with extended memory statistics,
they are returned in this entry; if the driver was compiled
without the statistics, 0 is returned.
The array contains NUM+2 entries, where NUM is the number
of distinct small block sizes. Entry [NUM] describes the
statistics of oversized small blocks (smalloc) resp. for
all slabs (slaballoc), entry [NUM+1] summarizes all large
blocks. Each entry is an array of these fields:
int DIM_ES_MAX_ALLOC:
Max number of allocated blocks of this size.
int DIM_ES_CUR_ALLOC:
Current number of allocated blocks of this size.
int DIM_ES_MAX_FREE:
Max number of allocated blocks of this size.
int DIM_ES_CUR_FREE:
Current number of allocated blocks of this size.
float DIM_ES_AVG_XALLOC:
Number of explicit allocation requests per
second.
float DIM_ES_AVG_XFREE:
Number of explicit deallocation requests per
second.
int DIM_ES_FULL_SLABS:
Number of fully used slabs (slaballoc only).
int DIM_ES_FREE_SLABS:
Number of fully free slabs (slaballoc only).
int DIM_ES_TOTAL_SLABS:
Total number of slabs: partially used, fully used
and fully free (slaballoc only).
The allocation/deallocation-per-second statistics do
not cover internal shuffling of the freelists.
The slab statistics (entry [NUM], slaballoc only) shows
in the AVG statistics the frequence with which slabs were
allocated from resp. returned to the large memory pool.
Status texts:
<what> == DI_STATUS_TEXT_MEMORY:
A printable string containing information about
the memory usage.
<what> == DI_STATUS_TEXT_TABLES:
A printable string containing information about
the LPC runtime.
<what> == DI_STATUS_TEXT_SWAP:
A printable string containing information about
the swap system.
<what> == DI_STATUS_TEXT_MALLOC:
A printable string containing information about
memory allocations.
<what> == DI_STATUS_TEXT_MALLOC_EXTENDED:
A printable strings with extended memory statistics
(if the driver was compiled with them).
HISTORY
Introduced in LDMud 3.5.0.
SEE ALSO
configure_driver(E), object_info(E), interactive_info(E),
dump_driver_info(E)
|
