MySQL数据库InnoDB存储引擎 异步IO(AIO)实现机制详解

最新推荐文章于 2024-10-08 17:58:52 发布
最新推荐文章于 2024-10-08 17:58:52 发布
阅读量3.4k 收藏 2
点赞数 1
分类专栏： 分布式存储 文章标签： aio mysqlaio

1.InnoDB存储引擎 AIO

insert into nkeys values (71,71,71,71,71);

Innodb的异步I/O，默认情况下使用linux原生aio，libaio。关于异步I/O的优势，可参考网文[18][19]；libaio的限制，可见网文[17]。下面详细分析Innodb 异步I/O的处理步骤。

 

2.聚簇索引IO

insert操作，读取聚簇索引页面，函数调用流程：

buf_page_get_gen -> buf_read_page -> buf_read_page_low -> fil_io ->

os_aio_func(type, mode) ->

  1. type = OS_FILE_READ; mode = OS_AIO_SYNC；使用os_aio_sync_array (其余的array包括：os_aio_read_array; os_aio_write_array; os_aio_ibuf_array; os_aio_log_array)
    1. 每个aio array，在系统启动时调用os0file.c::os_aio_init函数初始化

      os_aio_init(io_limit,

      srv_n_read_io_threads,

      srv_n_write_io_threads,

      SRV_MAX_N_PENDING_SYNC_IOS);

    2. io_limit： 每个线程可以并发处理多少pending I/O

      windows ->     io_limit = SRV_N_PENDING_IOS_PER_THREAD = 32

      linux ->         io_limit = 8 * SRV_N_PENDING_IOS_PER_THREAD = 8 * 32 = 256

      #define
      SRV_N_PENDING_IOS_PER_THREAD    OS_AIO_N_PENDING_IOS_PER_THREAD = 32

    3. srv_n_read_io_threads

      处理异步read I/O线程的数量

      innobase_read_io_threads/innodb_read_io_threads：通过参数控制

      因此系统可以并发处理的异步read page请求为：

      io_limit * innodb_read_io_threads

    os_aio_read_array = os_aio_array_create(n_read_segs * n_per_seg, n_read_segs);

    异步I/O主要包括两大类：

    1. 预读page

      需要通过异步I/O方式进行

    2. 主动Merge

      Innodb主线程对需要merge的page发出异步读操作，在read_thread中进行实际merge处理

注：如何确定将哪些read io请求分配给哪些read thread？

  1. 首先，每个read thread负责os_aio_read_array数组中的一部分。

    例如：thread0处理read_array[0, io_limit-1]；thread1处理read_array[io_limit, 2*io_limit - 1]，以此类推

  2. os_aio_array_reserve_slot函数中实现了array的分配策略(array未满时)。

    给定一个Aio read page，[space_id, page_no]，首先计算local_seg(local_thd):

    local_seg = (offset >> (UNIV_PAGE_SIZE_SHIFT + 6)) % array->n_segments;

    然后从read_array的local_seg * io_limit处开始向后遍历array，直到找到一个空闲slot。

    一来保证相邻的page，能够尽可能分配给同一个thread处理，提高aio(merge io request)性能；

    二来由于是循环分配，也基本上保证了每个thread处理的io基本一致。

  1. srv_n_write_io_threads

    处理异步write I/O线程的数量

    innobase_write_io_threads/innodb_write_io_threads：通过参数控制

    因此系统可以并发处理的异步write请求为：

    io_limit * innodb_write_io_threads

    超过此限制，必须将已有的异步I/O部分写回磁盘，才能处理新的请求。

  2. SRV_MAX_N_PENDING_SYNC_IOS

    同步I/O array的slots个数，同步I/O不需要处理线程

  3. log thread，ibuf thread个数均为1

os_aio_array_reserve_slot ->

  1. 在aio array中定位一个空闲array，aio前期准备工作
    1. array已满
      1. native aio：    os_wait_event(array->not_full); native aio，等待not_full信号
      2. 非native aio：os_aio_simulated_wake_handler_threads；模拟唤醒
    2. array未满
      1. WIN_ASYNC_IO(windows AIO)

        设置OVERLAPPED结构，使用的是Windows Overlapped I/O [5,6]

        ResetEvent(slot->handle)

      2. LINUX_NATIVE_AIO(Linux AIO)

      设置iocb结构

      然后根据type判断： io_prep_pread or io_prep_pwrite [7]

  2. 进行aio操作
    1. type = OS_FILE_READ
      1. use native aio
        1. windows: ReadFile
        2. Linux:    os_aio_linux_dispatch(array, slot);
          1. 将async io请求发送至linux kernel
          2. 调用io_submit函数进行aio发送

          iocb = &slot->control;

io_ctx_index = (slot->pos * array->n_segments) / array->n_slots;

ret = io_submit(array->aio_ctx[io_ctx_index], 1, &iocb);

  1. iocb结构在slot之中；io_context结构，相同segment共用一个
  1. use simulated aio
  1. type = OS_FILE_WRITE
    1. use native aio
      1. windows: WriteFile
      2. Linux:    os_aio_linux_dispatch(array, slot)
    2. use simulated aio

os_aio_windows_handle

  1. 特殊处理流程，windows下，若mode = OS_AIO_SYNC，则需要调用os_aio_windows_handle函数等待aio结束
    1. 判断当前是否为sync_array
      1. 若是，等待指定的slot aio操作完成：         WaitForSingleObject
      2. 若不是，等待array中所有的aio操作完成：    WaitForMultipleObjects
    2. 获取aio操作的结果
      1. GetOverlappedResult
    3. 最后释放当前slot
      1. os_aio_array_free_slot

os_aio_linux_handle

  1. 分析完os_aio_windows_handle函数，接着分析Linux下同样功能的函数：os_aio_linux_handle
    1. 无限循环，遍历array，直到定位到一个完成的I/O操作(slot->io_already_done)为止
    2. 若当前没有完成的I/O，同时有I/O请求，则进入os_aio_linux_collect函数
      1. os_aio_linux_collect：从kernel中收集更多的I/O请求
        1. 调用io_getevents函数，进入忙等，等待超时设置为OS_AIO_REAP_TIMEOUT

        /** timeout for each io_getevents() call = 500ms. */

        #define OS_AIO_REAP_TIMEOUT    (500000000UL)

        1. 若io_getevents函数返回ret > 0，说明有完成的I/O，进行一些设置，最主要是将slot->io_already_done设置为TRUE

          slot->io_already_done = TRUE;

        2. 若系统I/O处于空闲状态，那么io_thread线程的主要时间，都在io_getevents函数中消耗。

3.Unique索引IO

与聚簇索引IO完全一致，因为二者都必须读取页面，不能进行Insert Buffer优化。

4.Non-unique索引IO

与聚簇索引IO不一致，区分流程在于函数buf_page_get_gen

buf_page_get_gen

if (mode == BUF_GET_IF_IN_POOL || mode == BUF_PEEK_IF_IN_POOL || mode == BUF_GET_IF_IN_POOL_OR_WATCH)

return NULL;

对于non-unique索引，此时mode = BUF_GET_IF_IN_POOL；若page在buffer pool中，则返回page，否则不立即读取page，进行insert buffer优化。

由于不会调用buf_read_page函数，因此不会产生物理IO。那么non-unique索引的页面何时会读入buffer pool，与insert buffer进行merge呢？详见 InnoDB Insert Buffer实现详解。

 

5.InnoDB存储引擎 Simulated AIO

在Linux系统上，MySQL数据库InnoDB存储引擎除了可以使用Linux自带的libaio之外，其内部还实现了一种称之为Simulated aio功能，用以模拟系统AIO实现(其实，Simulated aio要早于linux native aio使用在innodb中，可参考网文[16])。前面的章节，已经分析了InnoDB存储引擎对于Linux原生AIO的使用，此处，再简单分析一下 Innodb simulated aio的实现方式。

以下一段话摘自Transactions on InnoDB网站[16]，简单说明了simulated aio在innodb中的处理方式。

… The query thread simply queues the request in an array and then returns to the normal working. One of the IO helper thread, which is a background thread, then takes the request from the queue and issues a synchronous IO call (pread/pwrite) meaning it blocks on the IO call. Once it returns from the pread/pwrite call, this helper thread then calls the IO completion routine on the block in question …

queue I/O request

os0file.c::os_aio_func;

os_aio_array_reserve_slot();

if (array->n_reserved == array_n_slots && !srv_use_native_aio)

os_aio_simuated_wake_handler_threads();

os_event_wait(array->not_full);

slot->… = …;

对于用户发起的read/write aio，simulated aio仍旧从对应的array中寻找空余slot，然后将aio request丢进此空闲slot，然后返回即可。

do I/O request by backend I/O thread

fil0fil.c::fil_aio_wait -> os0file.c::os_aio_simulated_handle

  • windows下处理异步I/O函数为os_aio_windows_handle；linux原生aio下为os_aio_linux_handle；而linux simulated aio下，对应的函数则是os_aio_simulated_handle
    • 步骤一，遍历array，找出请求时间超过2S的I/O，优先处理，防止饥饿
    • 步骤二，若步骤一没有定位到，则找出I/O request中，page_no最小的请求
    • 步骤三，再次遍历array，判断是否存在与步骤一或步骤二定位到的page相邻的page request，相邻的请求全部一次处理，处理函数如下：

os_file_read/write -> os_file_read/write_func -> os_file_pread/pwrite -> pread/pwrite

  • 调用pread/pwrite进行同步读/写
  • 在读写结束之后，做些后续处理，标识对应的slot，I/O操作完成

总结：

Linux simulated aio，实现简单，基本采用的仍旧是同步IO的方式。相对于Linux native aio，simulated aio最大的问题在于：每个I/O请求，最终都会调用一次pread/pwrite进行处理(除非可以进行相邻page的合并)，而Linux native aio，对于一个array，进行一次异步I/O处理即可。

6.AIO层次分析

  • InnoDB层面 (IO请求)

SRV_N_PENDING_IOS_PER_THREAD

一个InnoDB thread同时能够处理的异步I/O的数量

  • File System层面 (AIO queue)

    fs.aio-max-nr

    文件系统级别，可以同时进行的aio的数量上限

  • Disk层面 (IO queue)

    nr_request

单个disk，可以并发处理的I/O请求的个数

若当前磁盘为逻辑盘，那么真实的nr_request = nr_request * disks in raid

注：

彭立勋 (13:42:00):

FusionIO处理不是普通盘那样，普通磁盘消耗IO队列是匀速的，FIO是抖动式的

何登成 (13:42:50):

难道说要将aio队列调小，消除FIO的抖动？

彭立勋 (13:43:40):

例如FusionIO的处理能力是每10ms 100个IO，IO队列里有200个IO，FusionIO会一次拿走100，10ms内不再从IO队列里拿东西，然后再拿走100个

SAS盘是匀速的，每处理完一个就拿一个

何登成 (13:44:34):

那也没法解释为什么是10S抖动一次啊？

彭立勋 (13:44:39):

然后nr_request有个算法，如果IO队列达到2/3时，就认为系统阻塞了，就没响应了

彭立勋 (13:45:49):

所以如果AIO队列太长，一次写到磁盘IO队列上的东西太多，碰上FusionIO，就容易出现达到2/3，虽然很快就消失了，但是还是能看到突然阻塞这种情况

霸爷建议，观察nr_request用了多少，AIO队列长度保持磁盘IO队列的2/3以内

何登成 (13:47:16):

哦，有点理解了

就是要aio的队列最大长度，不超过nr_request的2/3

彭立勋 (13:47:22):

aio_nr是FS级的，nr_request是Disk级的

是的

霸爷就是这意思，只对FusionIO有效，SAS盘不是这样的

SAS盘尽管往里面堆

7.Linux AIO增强

InnoDB使用的linux native aio，仅仅支持以O_DIRECT方式打开的文件。针对此情况，大神Jens Axboe做了进一步的优化，提供了Buffered async IO，具体情况可参考其个人主页上的一篇文章：Buffered async IO。

 

8.软中断的影响

上面提到的两个问题点，是InnoDB引擎内部的，其实mysql在运行过程中，还有一个极大的与操作系统与硬件相关的问题点——(软)中断的处理。关于软中断的原理以及Linux下软中断的实现，可参考[25][26]。

在mysql系统中，最主要的软中断有两类：Disk软中断；网卡软中断。而软中断带来的问题是：所有的软中断由一个CPU集中处理，导致单个CPU利用率增加，同时处理软中断的性能下降。一个典型的例子如下：

mpstat -P ALL 2 3

Average: CPU %user %nice %sys %iowait %irq %soft %steal %idle intr/s

Average: all 1.07 0.00 0.37 0.12 0.08 0.04 0.00 98.31 1555.33

Average: 0 6.28 0.00 0.83 0.99 0.66 0.17 0.00 91.07 1555.00

Average: 1 0.00 0.00 0.17 0.00 0.00 0.00 0.00 99.83 0.00

Average: 2 0.00 0.00 0.17 0.00 0.00 0.00 0.00 99.83 0.00

Average: 3 0.82 0.00 1.31 0.00 0.00 0.00 0.00 97.88 0.00

上例中，intr/s列，表示CPU在internal时间段(2S)内，每秒CPU接收的中断的次数(intr /total)*100；%soft列，表示在internale时间段内，软中断时间(softirq/total)*100。可以看出，每秒总得中断 次数为1555.33，而CPU 0就处理了1555个，中断的处理分配极度不均衡。

解决的方案也很明确，将软中断处理分布到系统所有的CPU中即可。

关于网卡软中断对于MYSQL数据库性能的影响及解决方案，可参考网文 MYSQL数据库网卡软中断不平衡问题及解决方案 [22]。除此之外，Google与Facebook都曾经针对网卡软中断，做过相应的优化[23][27].

而对于Disk软中断，据我所知2002年一本漫画闯天涯同学，也对Linux做了优化，能够保证Disk软中断的处理在所有CPU中平均分布：block: improve rq_affinity placement。

关于中断(包括软硬中断)，Linux系统已经做了大量的优化，简单归纳起来，主要有以下一些：

  • 高级可编程中断控制(Advanced Programmable Interrupt Controller, APIC) [30]
  • 中断亲和力(SMP IRP Affinity) [28][29]
  • IRQ Balance [32]
  • MSI & MSI-X [34][35][36]
  • 网卡软中断处理[22][23][27]
  • 磁盘软中断处理[37]
  • 中断监控 [33]

cd520yy
关注
专栏目录
innodb学习（一）——innodb如何使用aio
阿罗
03-07 7131
Innodb从5.5开始使用linux的Native AIO（后面简称N-AIO），告别之前仿真的方式。我们下面从5.6.10的源码分析Innodb的Native AIO使用架构。        Innodb有N个io handler threads（N=1个ibuf_io_thread + 1个log_io_thread + innodb_read_io_threads个read_io_t
mysql 使用异步io_InnoDB引擎之-异步IO（Async IO）
weixin_30915487的博客
01-21 1142
InnoDB引擎有几个重点特性，为其带来了更好的性能和可靠性：插入缓冲(Insert Buffer)两次写(Double Write)自适应哈希索引(Adaptive Hash Index)异步IO(Async IO)刷新邻接页(Flush Neighbor Page)关于AIO与SIO为了提高磁盘操作性能，当前的数据库系统都采用异步IO的方式来处理磁盘操作。同步IO：我们常用的read/writ...
【MySQL技术内幕】08-异步IO
通往神秘的道路的专栏
10-08 698
为了提高磁盘操作性能,当前的数据库系统都采用异步IO(Asynchronous IO,AIO)的方式来处理磁盘操作。 InnoDB存储引擎亦是如此。 与AIO对应的是 Sync IO,即每进行一次IO操作,需要等待此次操作结束才能继续接下来的操作。但是如果用户发出的是一条索引扫描的查询,那么这条SQL查询语句可能需要扫描多个索引页,也就是需要进行多次的IO操作。在每扫描一个页并等待其完成后再进行下...
如何在 Python 中异步操作数据库？aiomysql、asyncpg、aioredis 使用介绍
最新发布
2401_86168842的博客
10-08 1187
但是对于 asyncpg 而言，实际上接收的是一个原生的 SQL 语句，是一个字符串，因此它不能像 aiomysql 一样自动识别 Select 对象，我们还需要手动将其转成字符串。以上我们演示了如何使用 asyncpg 来获取数据库中的记录，我们看到执行 select 语句的话，我们可以使用 conn.fetchrow(query) 来获取满足条件的单条记录，conn.fetch(query) 来获取满足条件的所有记录。怎么样，是不是很简单呢，和同步库的操作方式其实是类似的。
MySQL的InnoDB引擎的异步IO(AIO)简介
zhang_jiafeng的专栏
03-26 476
InnoDB引擎的数据存储是基于磁盘的（为什么强调Innodb呢，因为还有memory是基于内存的），也就是说数据是存储在磁盘上的，但是我们都知道，CPU和磁盘之间不可逾越的速度鸿沟。如果每次查询/修改数据，都同步地（或者说实时地）去查询磁盘/修改磁盘，那么数据库系统的性能，必然受到极大的负面影响。 为此，使用了一种异步IO的解决方案。解决方案是引入内存来解决CPU和磁盘的速度差异，再加上异步机制进而提高数据库性能。 大致就是，每次查询时，先从内存的缓冲池中检查，被查询的页是否在缓冲池中，不在话再去磁盘
Mysql文件系统—异步IO (AIO)
翔之天空的专栏
04-09 715
参照：《mysql内核：innodb存储引擎》第六章 MySQL · 引擎特性 · InnoDB IO子系统 ：http://mysql.taobao.org/monthly/2017/03/01/ MySQL · 源码分析 · InnoDB 异步IO工作流程 ：http://mysql.taobao.org/monthly/2017/07/...
InnoDB存储引擎体系架构
qq_43752469的博客
10-28 2624
一、InnoDB体系结构 InnoDB 存储引擎有多个内存块，这些内存块组成了一个大的内存池，负责的工作如下： 维护所有进程/线程需要访问的多个内部数据结构。 缓存磁盘上的数据，方便快速地读取，同时在对磁盘文件的数据修改之前在这里缓存。 重做日志缓冲（redo log）。 后台线程的作用：负责刷新内存池中的数据，保证缓冲池中的内存缓存的是最近的数据。将已修改的数据文件刷新到磁盘文件，同时保证在数据库发生异常的情况下 InnoDB 能恢复到正常运行状态。 二、后台线程 InnoDB存储引擎是多线程模型，
带你吃透MySQL系列：InnoDB引擎浅析
Trouvailless的博客
08-15 393
本文详细的解读了InnoDB的内存池结构，以及诸多InnoDB的特性。非常欢迎大家阅读文章后，提出宝贵的意见，每条评论我都会看，你们的支持将是我更新的动力！
MySQL大总结1-20（InnoDB存储引擎的关键特性、Insert Buffer、Double Write、异步IO、刷新临接页（Flush Neighbor Page））
阿鹏的笔记
04-02 1949
MySQL290题链接： https://blog.csdn.net/qq_18312025/article/details/79169903 MySQL结构图： 一、IT行业数据库布局分析 答：三类主机设备（图：） 组成DB服务器系统的硬件平台： 小型机：跑unix、稳定、可靠、贵 小型机可用pc server+linux或pc server+Wind...
mysql global status 状态变量详解一，innodb%writ相关
w1346561235的博客
11-21 1426
Innodb_buffer_pool_write_requests：写入buffer pool的请求数。理论上这个数量也等于每一个提交的事务修改的buffer pool中页*次。同一个页在一个事务中只累加一次，多个事务修改同一个page累加多次。原因是每一个事务在commit时都会将自身修改的page添加到flush列表，每次添加一个page，都会累加Innodb_buffer_pool_write_requests。具体的实现是，每一个mtr有一个自身的memory stack来存储修改的page，这个结
Mysql数据库管理系统
MKC__jiaoq的博客
12-05 2331
概述：MySQL是一个关系型数据库管理系统，由瑞典MySQLAB公司开发，目前属于 Oracle旗下公司。是一个真正的多用户、多线程SQL数据库服务器。SQL(结构化查询语言)是世界上最流行的和标准化的数据库语言。MySQL是以一个客户机/服务器结构的实现，它由一个服务器守护程序mysqld和很多不同的客户程序和库组成。SQL是一种标准化的语言，它使得存储、更新和存取信息更容易 Mysql整体架构 数据记录类型 日期 类型 大小(字节) 范围 格式 ...
mysql aio与并发执行线程_mysql 原理 ~ 线程与IO
weixin_32968007的博客
01-19 568
一 简介:今天来聊聊具体的线程和IO二 具体线程与作用1 master thread mysql的主要工作触发线程1 redo and binlog日志2 合并插入缓冲。3 脏页的刷新4 undo页回收5 产生一个ckp点2 IO THREAD 处理AIO模式的回调部分具体说明 AIO模式, 就是后台处理逻辑,然后先返回状态给前台,等后台处理完成,会调用回调函数进行二次操作,也就...
mysql 5.7 io 性能 aio_技术分享 | MySQL 主机该如何配置 fs.aio-max-nr
weixin_34529812的博客
01-27 253
作者：洪斌爱可生南区负责人兼技术服务总监，MySQL ACE，擅长数据库架构规划、故障诊断、性能优化分析，实践经验丰富，帮助各行业客户解决 MySQL 技术问题，为金融、运营商、互联网等行业客户提供 MySQL 整体解决方案。本文来源：转载自公众号-玩转MySQL*爱可生开源社区出品，原创内容未经授权不得随意使用，转载请联系小编并注明来源。MySQL 默认是启用 innodb_use_nativ...
scrapy 异步存储mysql大量数据_scrapy数据存储在mysql数据库的两种方式(同步和异步)...
weixin_39782433的博客
02-04 243
scrapy数据存储在mysql数据库的两种方式(同步和异步)发布时间：2020-10-19 14:38:24来源：脚本之家阅读：76作者：侠客云方法一：同步操作1.pipelines.py文件(处理数据的python文件)import pymysqlclass LvyouPipeline(object):def __init__(self):# connection databaseself.c...
mysql 5.7 io 性能 aio_深入理解MySQL的InnoDB引擎
weixin_30651345的博客
02-17 306
在MySQL中的引擎一文中说了，我们在几乎所有的情况下其实用的都是InnoDB引擎，这里我们就重点再看一下这个引擎，包括他的存储结构，线程模型和数据文件。我们可以通过show engine innodb status \G;(\G只是表示输出结果纵向表格输出)命令可以查看innodb引擎的的一些基本信息，如下图：image.pngimage.png上图中可以看到有线程、事务、文件IO，缓冲区，内存...
mac电脑安装mysql出现 aio read write
kanuoer的专栏
04-27 722
mac电脑安装mysql出现 aio read write 类似的错误信息
innodb学习笔记(一)  aio的使用
liangll的博客
10-04 775
innodb学习(一)aio的使用 这里先以mysql 5.7.26版本进行分析。 innodb可以配置aio线程的数量，在my.cnf中可以看到读线程和写线程数量的配置，这里一例各自为8。 实际代码中srv0start.cc负责aio的初始化，这里实际对应srv_n_read_io_threads和srv_n_write_io_threads两个参数； 当然除了指定的读线程和写线程外，还有一个log io thread和ibuf io thread。所以实际的io线程总数就是： srv..
MySQL AIO不足启动失败问题分析
joychenwenyu的博客
05-16 323
在分析问题之前我们需要先简单了解一下linux asynchronous I/O System以及在mysql的innodb场景中有哪些用处。
java mysql aio_Java中的NIO，BIO，AIO分别是什么
weixin_36111677的博客
02-03 170
Java中的NIO，BIO，AIO分别是什么BIO:同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。NIO:同步非阻塞，服务器...
MySQL数据库InnoDB存储引擎特性详解
"MySQL数据库中的InnoDB存储引擎是其核心特性之一，尤其对于需要处理大量在线事务处理(OLTP)的应用来说，InnoDB存储引擎提供了强大的支持。以下是关于InnoDB存储引擎特点的详细解释： 1. **支持外键**： InnoDB...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值