| 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. For lightweight objects |
| this is 0. |
| |
| 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_NUM_NAMED_OBJECT_TYPES: |
| Number of named object types. |
| |
| <what> == DI_NUM_NAMED_OBJECT_TYPES_TABLE_SLOTS: |
| Number of table entries for named object types. |
| |
| <what> == DI_NUM_COROUTINES: |
| Number of coroutines. |
| |
| <what> == DI_NUM_LWOBJECTS: |
| Number of lightweight objects. |
| |
| <what> == DI_NUM_LPC_PYTHON_REFS: |
| Number of references to Python objects from LPC. |
| |
| <what> == DI_NUM_PYTHON_LPC_REFS: |
| Number of references to LPC values from Python. |
| |
| <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. |
| |
| <what> == DI_SIZE_NAMED_OBJECT_TYPES_TABLE: |
| The size of the table for named object types. |
| |
| <what> == DI_SIZE_LWOBJECTS: |
| The size of all lightweight objects (not counting the size |
| of the values of their variables). |
| |
| <what> == DI_SIZE_COROUTINES |
| The size of all coroutines (not counting the size of any |
| values held by the coroutines). |
| |
| |
| |
| 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). |
| |
| |
| Misc Status: |
| |
| <what> == DI_NUM_SIMUL_EFUNS_TABLED: |
| The number of known simul_efuns (active or not) in the simul_efun |
| table. |
| |
| |
| HISTORY |
| Introduced in LDMud 3.5.0. |
| |
| SEE ALSO |
| configure_driver(E), object_info(E), interactive_info(E), |
| dump_driver_info(E) |