MySQL源码之--Table_cache

最新推荐文章于 2023-08-11 14:32:31 发布
最新推荐文章于 2023-08-11 14:32:31 发布
阅读量351 收藏
点赞数
分类专栏： MySQL源码 MySQL 文章标签： mysql 数据库 sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37389157/article/details/120440834
版权

一.table_cache 相关参数

1.open_files_limit
2.max_connections
3.table_open_cache
4.table_definition_cache

问题？

经常会看到自己my.cnf设置的那四个值和在MySQL中看到的值不一样.

我修改了其中一个参数，结构发现所有的上面的四个参数都发生了变化。
参数到底应该设置为多少合适？

二.源码分析之初始化

1.常量定义

源码位置:/sql/sql_const.h

#define TABLE_OPEN_CACHE_MIN    400
#define TABLE_OPEN_CACHE_DEFAULT 2000
#define TABLE_DEF_CACHE_DEFAULT 400
#define MAX_CONNECTIONS_DEFAULT 151
#define TABLE_DEF_CACHE_MIN     400

源码位置:/mysql-5.7.33/my_global.h

#ifdef _WIN32
#define MY_FILE_MIN  2048
#else
#define MY_FILE_MIN  0
#endif

#ifdef _WIN32
#define MY_NFILE (16384 + MY_FILE_MIN)
#else
#define MY_NFILE 64
#endif

#define OS_FILE_LIMIT	UINT_MAX

2.变量静态文件

源码位置:/mysql-5.7.33/sql/sys_vars.cc

static Sys_var_ulong Sys_open_files_limit(
       "open_files_limit",
       "If this is not 0, then mysqld will use this value to reserve file "
       "descriptors to use with setrlimit(). If this value is 0 then mysqld "
       "will reserve max_connections*5 or max_connections + table_open_cache*2 "
       "(whichever is larger) number of file descriptors",
       READ_ONLY GLOBAL_VAR(open_files_limit), CMD_LINE(REQUIRED_ARG),
       VALID_RANGE(0, OS_FILE_LIMIT), DEFAULT(0), BLOCK_SIZE(1),
       NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(NULL), ON_UPDATE(NULL),
       NULL,
       sys_var::PARSE_EARLY);

static Sys_var_ulong Sys_max_connections(
       "max_connections", "The number of simultaneous clients allowed",
       GLOBAL_VAR(max_connections), CMD_LINE(REQUIRED_ARG),
       VALID_RANGE(1, 100000),
       DEFAULT(MAX_CONNECTIONS_DEFAULT),
       BLOCK_SIZE(1),
       NO_MUTEX_GUARD,
       NOT_IN_BINLOG,
       ON_CHECK(0),
       ON_UPDATE(0),
       NULL,
       sys_var::PARSE_EARLY);


static bool fix_table_cache_size(sys_var *self, THD *thd, enum_var_type type)
{
  table_cache_size_per_instance= table_cache_size / table_cache_instances;
  return false;
}

static Sys_var_ulong Sys_table_cache_size(
       "table_open_cache", "The number of cached open tables "
       "(total for all table cache instances)",
       GLOBAL_VAR(table_cache_size), CMD_LINE(REQUIRED_ARG),
       VALID_RANGE(1, 512*1024), DEFAULT(TABLE_OPEN_CACHE_DEFAULT),
       BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(NULL),
       ON_UPDATE(fix_table_cache_size),
       NULL,
       sys_var::PARSE_EARLY);

static Sys_var_ulong Sys_table_cache_instances(
       "table_open_cache_instances", "The number of table cache instances",
       READ_ONLY GLOBAL_VAR(table_cache_instances), CMD_LINE(REQUIRED_ARG),
       VALID_RANGE(1, Table_cache_manager::MAX_TABLE_CACHES),
       DEFAULT(Table_cache_manager::DEFAULT_MAX_TABLE_CACHES),
       BLOCK_SIZE(1), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(NULL),
       ON_UPDATE(NULL), NULL,
       sys_var::PARSE_EARLY);

static Sys_var_ulong Sys_table_def_size(
       "table_definition_cache",
       "The number of cached table definitions",
       GLOBAL_VAR(table_def_size),
       CMD_LINE(REQUIRED_ARG, OPT_TABLE_DEFINITION_CACHE),
       VALID_RANGE(TABLE_DEF_CACHE_MIN, 512*1024),
       DEFAULT(TABLE_DEF_CACHE_DEFAULT),
       BLOCK_SIZE(1),
       NO_MUTEX_GUARD,
       NOT_IN_BINLOG,
       ON_CHECK(NULL),
       ON_UPDATE(NULL),
       NULL,
       sys_var::PARSE_EARLY);

三.源码分析之具体流程

1.初始化流程

位置:/mysql-5.7.33/sql/mysqld.cc

#endif
init_sql_statement_names();
sys_var_init(); //系统参数初始化
ulong requested_open_files; //requested_open_files 非常重要的变量
adjust_related_options(&requested_open_files); //

#ifdef WITH_PERFSCHEMA_STORAGE_ENGINE
if (ho_error == 0)
{
if (!opt_help && !opt_bootstrap)
{
/* Add sizing hints from the server sizing parameters. */ //下面这些参数会根据服务器的相关参数进行调整，也就是adjust_related_options这个函数返回的值去设置下面的参数
pfs_param.m_hints.m_table_definition_cache= table_def_size;
pfs_param.m_hints.m_table_open_cache= table_cache_size;
pfs_param.m_hints.m_max_connections= max_connections;
pfs_param.m_hints.m_open_files_limit= requested_open_files;
pfs_param.m_hints.m_max_prepared_stmt_count= max_prepared_stmt_count;

PSI_hook= initialize_performance_schema(&pfs_param);
if (PSI_hook == NULL && pfs_param.m_enabled)
{
pfs_param.m_enabled= false;
sql_print_warning("Performance schema disabled (reason: init failed).");
}
}
}
#else
.......
void adjust_related_options(ulong *requested_open_files)
{
/* In bootstrap, disable grant tables (we are about to create them) */
if (opt_bootstrap)
opt_noacl= 1;
//由于这几个参数会互相影响对方的值，所以可以看出来这几个参数的初始化顺序，以及依赖很关键 
/* The order is critical here, because of dependencies. */
adjust_open_files_limit(requested_open_files);
adjust_max_connections(*requested_open_files);
adjust_table_cache_size(*requested_open_files);
adjust_table_def_size();
}
...........

2.open_files_limit相关

位置:/mysql-5.7.33/sql/mysqld.cc

void adjust_open_files_limit(ulong *requested_open_files)
{
  ulong limit_1;
  ulong limit_2;
  ulong limit_3;
  ulong request_open_files;
  ulong effective_open_files;

  /* MyISAM requires two file handles per table. */
  limit_1= 10 + max_connections + table_cache_size * 2;

  /*
    We are trying to allocate no less than max_connections*5 file
    handles (i.e. we are trying to set the limit so that they will
    be available).
  */
  limit_2= max_connections * 5;

  /* Try to allocate no less than 5000 by default. */
  limit_3= open_files_limit ? open_files_limit : 5000;

  request_open_files= max<ulong>(max<ulong>(limit_1, limit_2), limit_3);

  /* Notice: my_set_max_open_files() may return more than requested. */
  effective_open_files= my_set_max_open_files(request_open_files);   //这个函数非常重要，下面的值都要根据这个去判断 my_set_max_open_files

  if (effective_open_files < request_open_files)
  {
    if (open_files_limit == 0)
    {
      sql_print_warning("Changed limits: max_open_files: %lu (requested %lu)",
                        effective_open_files, request_open_files);
    }
    else
    {
      sql_print_warning("Could not increase number of max_open_files to "
                        "more than %lu (request: %lu)",
                        effective_open_files, request_open_files);
    }
  }

  open_files_limit= effective_open_files;
  if (requested_open_files)
    *requested_open_files= min<ulong>(effective_open_files, request_open_files);
}

my_set_max_open_files

/*
  Change number of open files

  SYNOPSIS:
    my_set_max_open_files()
    files		Number of requested files

  RETURN
    number of files available for open
*/

uint my_set_max_open_files(uint files)
{
  struct st_my_file_info *tmp;
  DBUG_ENTER("my_set_max_open_files");
  DBUG_PRINT("enter",("files: %u  my_file_limit: %u", files, my_file_limit));

  files+= MY_FILE_MIN;   //0         
  files= set_max_open_files(MY_MIN(files, OS_FILE_LIMIT));  //OS_FILE_LIMIT = UINT_MAX 类型为 unsigned int 的变量的最大值。 4294967295，这里应该为0
  if (files <= MY_NFILE)
    DBUG_RETURN(files);

  if (!(tmp= (struct st_my_file_info*) my_malloc(key_memory_my_file_info,
                                                 sizeof(*tmp) * files,
						 MYF(MY_WME))))
    DBUG_RETURN(MY_NFILE);

  /* Copy any initialized files */
  memcpy((char*) tmp, (char*) my_file_info,
         sizeof(*tmp) * MY_MIN(my_file_limit, files));
  memset((tmp + my_file_limit), 0, 
        MY_MAX((int) (files - my_file_limit), 0) * sizeof(*tmp));
  my_free_open_file_info();			/* Free if already allocated */
  my_file_info= tmp;
  my_file_limit= files;
  DBUG_PRINT("exit",("files: %u", files));
  DBUG_RETURN(files);
}



/*
  This value is certainly wrong on all 64bit platforms,
  and also wrong on many 32bit platforms.
  It is better to get a compile error, than to use a wrong value.
#ifndef RLIM_INFINITY
#define RLIM_INFINITY ((uint) 0xffffffff)
#endif
*/

static uint set_max_open_files(uint max_file_limit)
{
  struct rlimit rlimit;
  uint old_cur;
  DBUG_ENTER("set_max_open_files");
  DBUG_PRINT("enter",("files: %u", max_file_limit));

  if (!getrlimit(RLIMIT_NOFILE,&rlimit))    //判断是否获取成功，获得open file的当前值 ulimit -n /或者是服务中的这个LimitNOFILE
  {
    old_cur= (uint) rlimit.rlim_cur;    //拿到RLIMIT_NOFILE软限制
    DBUG_PRINT("info", ("rlim_cur: %u  rlim_max: %u",
      (uint) rlimit.rlim_cur,
      (uint) rlimit.rlim_max));
    if (rlimit.rlim_cur == (rlim_t) RLIM_INFINITY)  //RLIM_INFINITY表示对资源不做限制，如果得到的值是unlimited
      rlimit.rlim_cur = max_file_limit;
    if (rlimit.rlim_cur >= max_file_limit)
      DBUG_RETURN(rlimit.rlim_cur);   /* purecov: inspected */
    rlimit.rlim_cur= rlimit.rlim_max= max_file_limit;
    if (setrlimit(RLIMIT_NOFILE, &rlimit))
      max_file_limit= old_cur;      /* Use original value */   //655350
    else
    {
      rlimit.rlim_cur= 0;     /* Safety if next call fails */
      (void) getrlimit(RLIMIT_NOFILE,&rlimit);  //655350
      DBUG_PRINT("info", ("rlim_cur: %u", (uint) rlimit.rlim_cur));
      if (rlimit.rlim_cur)      /* If call didn't fail */
  max_file_limit= (uint) rlimit.rlim_cur;  //655350
    }
  }
  DBUG_PRINT("exit",("max_file_limit: %u", max_file_limit));
  DBUG_RETURN(max_file_limit);
}

#else
static uint set_max_open_files(uint max_file_limit)
{
  /* We don't know the limit. Return best guess */
  return MY_MIN(max_file_limit, OS_FILE_LIMIT);
}

3.max_connection

void adjust_max_connections(ulong requested_open_files)
{
ulong limit;

limit= requested_open_files - 10 - TABLE_OPEN_CACHE_MIN * 2;

if (limit < max_connections)
{
sql_print_warning("Changed limits: max_connections: %lu (requested %lu)",
limit, max_connections);

// This can be done unprotected since it is only called on startup.
max_connections= limit;
}
}

4.table_open_cache

void adjust_table_cache_size(ulong requested_open_files)
{
ulong limit;

limit= max<ulong>((requested_open_files - 10 - max_connections) / 2,
TABLE_OPEN_CACHE_MIN);

if (limit < table_cache_size)
{
sql_print_warning("Changed limits: table_open_cache: %lu (requested %lu)",
limit, table_cache_size);

table_cache_size= limit;
}

table_cache_size_per_instance= table_cache_size / table_cache_instances;
}

5.table_definition_cache

void adjust_table_def_size()
{
ulong default_value;
sys_var *var;

default_value= min<ulong> (400 + table_cache_size / 2, 2000);
var= intern_find_sys_var(STRING_WITH_LEN("table_definition_cache"));
DBUG_ASSERT(var != NULL);
var->update_default(default_value);

if (! table_definition_cache_specified)
table_def_size= default_value;
}

四.取值

1.open_files_limit

limit_1= 10 + max_connections + table_cache_size * 2;
limit_2= max_connections * 5;
limit_3= open_files_limit ? open_files_limit : 5000;
request_open_files= max(max(limit_1, limit_2), limit_3);

2.max_connections

min(requested_open_files - 10 - TABLE_OPEN_CACHE_MIN * 2,max_connections)

3.table_open_cache

min(max((requested_open_files - 10 - max_connections) / 2, TABLE_OPEN_CACHE_MIN),table_cache_size)

4.table_definition_cache

配置文件有值取值优先

min (400 + table_cache_size / 2, 2000)

所以我们在真正遇到问题的时候，应该先从max_connections去入手。再去调节其他参数。

渔不是鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
MySQL性能优化之table_cache配置参数浅析
01-19
table_cache是一个非常重要的MySQL性能参数，它在5.1.3之后的版本中叫做table_open_cache。table_cache主要用于设置table高速缓存的数量。由于每个客户端连接都会至少访问一个表，因此此参数的值与max_connections有关。 缓存机制 当某一连接访问一个表时，MySQL会检查当前已缓存表的数量。如果该表已经在缓存中打开，则会直接访问缓存中的表已加快查询速度；如果该表未被缓存，则会将当前的表添加进缓存并进行查询。 在执行缓存操作之前，table_cache用于限制缓存表的最大数目：如果当前已经缓存的表未达到table_cache，则会将新表添加进来
mysql table_cache设置,MySQL性能优化之table_cache配置参数浅析
weixin_39819152的博客
03-17 672
table_cache是一个非常重要的MySQL性能参数，它在5.1.3之后的版本中叫做table_open_cache。table_cache主要用于设置table高速缓存的数量。由于每个客户端连接都会至少访问一个表，因此此参数的值与max_connections有关。缓存机制当某一连接访问一个表时，MySQL会检查当前已缓存表的数量。如果该表已经在缓存中打开，则会直接访问缓存中的表已加快查询速...
MySQL- table cache最详细笔记
授人以鱼不如授之以渔
09-23 920
参数: table_open_cache文件句柄，描述符fd， table_definition_cache元数据，.frm文件,初始化的时候加载一次。 状态值: Open_tables。 当前打开表的数量,可以通过命令show open tables查看。第一次开始会缓存系统表. Opened_tables 通过my_open（）函数打开的表数量 Open_table_definitions 当前打开表的定义数量，缓存.frm文件 Opened_table_definitions。打开表的定义的总
mysql设置table_cache_改进MySQL的table_cache
weixin_39808803的博客
02-02 349
在MySQL里面有一个参数table_cache，当设置过大时，会产生明显的效率下降。这是因为扫描open_cache哈希表时，使用的线性扫描，时间复杂度为O(n)，mysql的bug list上有人提供了一个patch(首先，我们分析一下mysql在打开一个表时如何工作：在mysql里，table_cache是一个比较重要的参数。由于多线程机制，每个线程独自打开自己需要的标的文件描述符，而不是共...
MySQL table_cache 优化(四)
weixin_33675507的博客
04-19 132
mysql查询tables cache的最大数： show variables like 'table_cache'; mysql查询当前系统已经打开的描述符命令： show status like 'open_tables'; 一、调整table cache table_cache 参数设置表高速缓存的数目。每个连接进来，都会至少打开一个表缓存。因此，...
2022年优秀-MySQL服务器的配置与管理练习讲解.pptx
11-14
4. 调整MySQL性能参数table_cache，可以在my.cnf配置文件中增加： ``` table_cache = 512 ``` 然后重启MySQL服务使更改生效。 **4. 数据库操作** 在manage数据库中创建名为student的表，包含name和telephone两个...
RockyLinux9.0 yum安装 mysql8.0
09-02
./mysqld --initialize --user=mysql --datadir=/appdata/data_mysql --basedir=/usr/local/mysql --lower_case_table_names=1 ``` 创建`my.cnf`配置文件： ```bash cd /etc vim my.cnf ``` 添加以下配置内容...
mysql5.7.23源码编译包带boost
08-05
8. **SQL标准的兼容性**：MySQL 5.7在遵循SQL标准方面取得了显著进步，例如支持窗口函数和 Common Table Expressions（CTE），使SQL语句编写更为简洁和强大。 综上所述，MySQL 5.7.23 源码编译包带Boost是一个全面...
Linux下Centos7安装Mysql5.7.19的详细教程
09-09
table_open_cache = 128 max_allowed_packet = 4M innodb_log_file_size = 300 ``` 这里，我们设置了端口、套接字位置、字符集以及日志等配置。 为了使MySQL在系统启动时自动运行，可以使用以下命令： ``` ...
MySQL5.7解压版
05-31
2. **性能提升**：MySQL5.7引入了性能改进，例如Query Cache的改进，使查询缓存更加高效；还有优化的索引处理，如Index Condition Pushdown（ICP），允许在索引查找过程中更早地应用过滤条件，减少回表操作。 3. **...
MySQL thread_cache和table_cache详解
10-15
THREAD_CACHE MySQL里面为了提高客户端请求创建连接过程的性能,提供了一个连接池也就是 Thread_Cache池,将空闲的连接线程放在连接池中,而不是立即销毁.这样的好处就是,当又有一个新的请求的时候,mysql不会立即去创建连接 线程,而是先去Thread_Cache中去查找空闲的连接线程,如果存在则直接使用,不存在才创建新的连接线程.
mysql table_cache设置_MySQL table_cache优化
weixin_36268722的博客
02-07 363
http://www.7dtest.com/site/thread-5951-1-1.htmltable_cache 参数设置表高速缓存的数目。每个连接进来，都会至少打开一个表缓存。因此， table_cache 的大小应与 max_connections 的设置有关。例如，对于 200 个并行运行的连接，应该让表的缓存至少有 200 × N ，这里 N 是应用可以执行的查询的一个联接中表的最大数...
关于mysql缓冲和缓存设置介绍
最新发布
hdxx2022的博客
08-11 1822
以上信息是默认配置，其注释意思是说，MYSQL的查询缓存用于缓存select查询结果，并在下次接收到同样的查询请求时，不再执行实际查询处理而直接返回结果，有这样的查询缓存能提高查询的速度，使查询性能得到优化，前提条件是你有大量的相同或相似的查询，而很少改变表里的数据，否则没有必要使用此功能。理想情况下，在内存中创建临时表。这里query_cache_size的值是134217728，我们设置的是128M，实际是一样的，只是单位不同，可以自己换算下：134217728 = 128*1024*1024。
mysql table_cache设置_【MySQL】关于table cache的相关参数 【转】
weixin_42395498的博客
01-19 411
一、状态值和变量：1.1在MySQL的show status中有2个状态值：Open_tables和Opened_tables。这2个值代表的意思如下：Open_tables ：代表当前打开表的数量。Opened_tables：代表自从MySQL启动后，打开表的数量。(1)对于myisam存储引擎，打开1张表需要2个文件描述符(一个.MYD文件，一个.MYI文件)。(2)对于innodb存储引擎...
MySQL 5.6 Table cache 简介
02-14 214
一、Table Cache MySQL 5.6后，引入了“table_cache_instances”参数来控制 table cache instance的个...
mysql ftwrl_社区投稿 | MySQL：FTWRL一个奇怪的堵塞现象和其堵塞总结
weixin_29215391的博客
02-05 448
一、两种不同的现象首先建立一张有几条数据的表就可以了，我这里是 baguait1 表了。案例1步骤2“flush table with read lock;”操作等待状态为“Waiting for global read lock”，如下：mysql>selectId,State,Infofrominformation_schema.processlistwherecomm...
mysql设置table_cache_MySQL 关于Table cache设置
weixin_42565402的博客
01-20 581
原文链接：https://www.modb.pro/db/15158摘要：mysql table相关参数理解因为今天突然有个凌晨5点值班任务，随意翻起同事的书来，看到表对象缓存，这个跟自己平时理解，稍微有差异。所以整理了一下table_definition_cache，table_open_cache和table_open_cache_instances。先看看官网怎么说:1.table_defi...
MySQL性能优化之table_cache
董董的^数据空间
07-10 1085
问题现象 俺们的数据库都是由Oracle emcc进行监控预警的。 这两天有很多这样的报错： Increase the value of table_cache in small increments dynamically and monitor the Opened_tables status variable or the Opened Tables graph on the Graphs tab. If the value is very large or increases rapidly, y
--lower_case_table_names=1 --restart always
05-31
`--lower_case_table_names=1` 是 MySQL 的一个参数，它表示将所有的表名转换成小写字母，这可以避免在 Linux 和 Windows 系统下表名大小写不一致的问题。这个参数可以在启动容器时通过 `-e` 参数设置，示例如下： ``` docker run -d --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=yourpassword -e MYSQL_LOWER_CASE_TABLE_NAMES=1 mysql:latest ``` 另外，`--restart always` 是 Docker 的一个参数，它表示容器在退出后总是自动重启。这个参数也可以在启动容器时设置，示例如下： ``` docker run -d --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=yourpassword --restart always mysql:latest ``` 你也可以将两个参数同时设置： ``` docker run -d --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=yourpassword -e MYSQL_LOWER_CASE_TABLE_NAMES=1 --restart always mysql:latest ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

渔不是鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值