Spec-Zone .ru
спецификации, руководства, описания, API
|
The following list indicates some of the ways that the mysqld server uses memory. Where applicable, the name of the system variable relevant to the memory use is given:
All threads share the MyISAM
key buffer; its size is determined by the key_buffer_size
variable. Other buffers used by the server are allocated
as needed. See Section 8.11.2, "Tuning Server
Parameters".
Each thread that is used to manage client connections uses some thread-specific space. The following list indicates these and which variables control their size:
A stack (variable thread_stack
)
A connection buffer (variable net_buffer_length
)
A result buffer (variable net_buffer_length
)
The connection buffer and result buffer each begin with a size equal to net_buffer_length
bytes, but are dynamically enlarged up to max_allowed_packet
bytes as needed. The result buffer shrinks to net_buffer_length
bytes after each SQL statement. While a
statement is running, a copy of the current statement string is also allocated.
All threads share the same base memory.
When a thread is no longer needed, the memory allocated to it is released and returned to the system unless the thread goes back into the thread cache. In that case, the memory remains allocated.
The myisam_use_mmap
system variable can be set to 1 to enable memory-mapping
for all MyISAM
tables.
Each request that performs a sequential scan of a table allocates a read buffer (variable read_buffer_size
).
When reading rows in an arbitrary sequence (for example, following a sort), a random-read buffer (variable read_rnd_buffer_size
) may be allocated to avoid disk seeks.
All joins are executed in a single pass, and most joins can be done without even
using a temporary table. Most temporary tables are memory-based hash tables. Temporary tables with a
large row length (calculated as the sum of all column lengths) or that contain BLOB
columns are stored on disk.
If an internal in-memory temporary table becomes too large, MySQL handles this automatically by
changing the table from in-memory to on-disk format, to be handled by the MyISAM
storage engine. You can increase the permissible temporary table size as described in Section 8.4.3.3, "How MySQL Uses
Internal Temporary Tables".
Most requests that perform a sort allocate a sort buffer and zero to two temporary files depending on the result set size. See Section C.5.4.4, "Where MySQL Stores Temporary Files".
Almost all parsing and calculating is done in thread-local and reusable memory pools. No memory overhead is needed for small items, so the normal slow memory allocation and freeing is avoided. Memory is allocated only for unexpectedly large strings.
For each MyISAM
table that is opened, the index file
is opened once; the data file is opened once for each concurrently running thread. For each concurrent
thread, a table structure, column structures for each column, and a buffer of size 3 *
are allocated (where N
N
is the maximum row length, not counting BLOB
columns). A BLOB
column requires five to eight bytes plus the length of the BLOB
data. The MyISAM
storage engine
maintains one extra row buffer for internal use.
For each table having BLOB
columns, a buffer is enlarged dynamically to read in larger BLOB
values. If you scan a table, a buffer as large as the largest BLOB
value is allocated.
Handler structures for all in-use tables are saved in a cache and managed as a
FIFO. The initial cache size is taken from the value of the table_open_cache
system variable. If a table has been used by two
running threads at the same time, the cache contains two entries for the table. See Section
8.4.3.1, "How MySQL Opens and Closes Tables".
A FLUSH TABLES
statement or mysqladmin flush-tables command closes all tables that
are not in use at once and marks all in-use tables to be closed when the currently executing thread
finishes. This effectively frees most in-use memory. FLUSH TABLES
does not return until all tables have been closed.
The server caches information in memory as a result of GRANT
, CREATE
USER
, CREATE SERVER
,
and INSTALL PLUGIN
statements. This memory is not released by the
corresponding REVOKE
, DROP
USER
, DROP SERVER
,
and UNINSTALL PLUGIN
statements, so for a server that executes many instances of the statements that cause caching, there
will be an increase in memory use. This cached memory can be freed with FLUSH PRIVILEGES
.
ps and other system status programs may report that mysqld uses a lot of memory. This may be caused by thread stacks
on different memory addresses. For example, the Solaris version of ps counts the unused memory between stacks as used memory. To
verify this, check available swap with swap -s
. We test mysqld with several memory-leakage detectors (both
commercial and Open Source), so there should be no memory leaks.