找回密码
 注册
关于网站域名变更的通知
查看: 385|回复: 1
打印 上一主题 下一主题

Linux内核设计与实现之页高速缓存和页回写

[复制链接]

该用户从未签到

跳转到指定楼层
1#
发表于 2021-2-19 11:06 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式

EDA365欢迎您登录!

您需要 登录 才可以下载或查看,没有帐号?注册

x

" ^- W9 F: \4 y: m5 K7 V主要内容:/ A% @. z+ l* N; ^  N6 K( V$ b6 M

" G2 B0 n2 K; u
  • 缓存简介
  • 页高速缓存
  • 页回写
    ) Y) q# Q  ?/ S2 H: P# V

2 e: f, L0 k1 e' j# u2 [
  A5 o: l* V) y1. 缓存简介& P% `* q  k" ?! K' C
在编程中,缓存是很常见也很有效的一种提高程序性能的机制。
5 ~% C4 P( b. p- c; G& T
* B% m. n% G3 U+ Qlinux内核也不例外,为了提高I/O性能,也引入了缓存机制,即将一部分磁盘上的数据缓存到内存中。7 Z; t8 @5 \3 z6 q% ]
$ a$ ^' I* h6 ^% Q5 O
: w/ \; E9 V: Z# Q
6 D2 O, Y/ O2 R5 Q# X
1.1 原理
% c9 P- ^& {4 m( z4 o9 S. u6 H. Y0 E( i" P
之所以通过缓存能提高I/O性能是基于以下2个重要的原理:
9 U# c7 \0 B, }- ~# b/ S' h% w6 @
' d9 l& i) T" V7 B* J
  • CPU访问内存的速度远远大于访问磁盘的速度(访问速度差距不是一般的大,差好几个数量级)
  • 数据一旦被访问,就有可能在短期内再次被访问(临时局部原理)6 [+ Q1 w5 E2 Z5 l3 N
/ I5 |, M; Y) x6 j7 w' }
% ^$ G. S$ y& C) m/ o! Q7 I
1.2 策略& H6 D- O2 X/ K

6 [- Q6 x3 T( N1 ~1 e& B) i' [缓存的创建和读取没什么好说的,无非就是检查缓存是否存在要创建或者要读取的内容。
0 m  u; A1 U! H# Q/ t7 a
+ L  h; |/ D; W: X' S但是写缓存和缓存回收就需要好好考虑了,这里面涉及到「缓存内容」和「磁盘内容」同步的问题。
0 ]$ T4 P4 ]3 f4 B3 {; u! F% i4 Z* V5 ?
1.2.1 「写缓存」常见的有3种策略1 x5 C/ L  K3 x/ Z

6 H# i$ t$ e: o4 {0 E6 n/ H! p7 K
  • 不缓存(nowrite) :: 也就是不缓存写操作,当对缓存中的数据进行写操作时,直接写入磁盘,同时使此数据的缓存失效
  • 写透缓存(write-through) :: 写数据时同时更新磁盘和缓存
  • 回写(copy-write or write-behind) :: 写数据时直接写到缓存,由另外的进程(回写进程)在合适的时候将数据同步到磁盘$ R0 }- A' ]3 C" C: ?" }! k

2 h: a& O& {, ~! j3 w* Q  C& ~# C* k
3种策略的优缺点如下:( p' |$ c, Z# Q7 e. ~

' W, |, G7 O* n1 O8 Q
策略
复杂度
性能
不缓存简单缓存只用于读,对于写操作较多的I/O,性能反而会下降
写透缓存简单提升了读性能,写性能反而有些下降(除了写磁盘,还要写缓存)
回写复杂读写的性能都有提高(目前内核中采用的方法)
. N4 j1 Y; A" j; _9 v6 G2 c2 h
' j4 |; a  P) n# q+ |

" k( m6 ~% m; {8 ^# b9 V0 B( \9 s/ J1.2.2 「缓存回收」的策略
) n' c- G7 G5 `$ c' L5 R
3 m( T% O' T7 ^% r$ Z
  • 最近最少使用(LRU) :: 每个缓存数据都有个时间戳,保存最近被访问的时间。回收缓存时首先回收时间戳较旧的数据。
  • 双链策略(LRU/2) :: 基于LRU的改善策略。具体参见下面的补充说明
    & E* {6 D4 o3 O" n4 ]
: ?% x9 U- D: d, D  ]* s" a
" H+ M9 H3 f" Y! [% |# D
补充说明(双链策略):1 \! |3 M+ [' o8 ^0 x2 V4 P: S$ o
2 x! \4 S# R) a. p
双链策略其实就是 LRU(Least Recently Used) 算法的改进版。
+ e& V2 X& g* `- J, d6 S
) V9 p5 S8 b  @* O: w; g它通过2个链表(活跃链表和非活跃链表)来模拟LRU的过程,目的是为了提高页面回收的性能。) w. l) x- w/ G; ^+ s4 {
" v- O8 L$ w+ n$ R/ \3 K: r% M
页面回收动作发生时,从非活跃链表的尾部开始回收页面。) l- A7 T/ L$ d; m' d' O

4 @7 ?/ T! O! S* [2 E 6 p" p3 F% q2 G* B! h. F

6 b6 M0 M9 I) u1 i' Z, s* U; k双链策略的关键就是页面如何在2个链表之间移动的。  R7 @3 U7 g- T* Y- c2 R# a
3 V" L- i. H+ a% k4 z2 q- i, l& ^! ?
双链策略中,每个页面都有2个标志位,分别为- Y* w# E0 z9 {0 `& G3 c$ e* F7 h

3 F! A5 x( n! R5 Y1 y5 o& n0 mPG_active - 标志页面是否活跃,也就是表示此页面是否要移动到活跃链表; K1 `- B2 e" C* C' W  u9 R$ H; @/ L, k
: ?6 L6 }+ Q0 m( D3 m4 U
PG_referenced - 表示页面是否被进程访问到
9 v& D; S' s4 x; A$ d' e% m; r  [, ?& P

2 P2 b' B- F* K" U! d+ a  w4 X/ X& {' @5 D% G5 z- Q
页面移动的流程如下:  o3 N6 P2 [( ~& j( A; _  H* E! B

' y4 i7 \: p! D- q$ ^/ ]6 N( \
  • 当页面第一次被被访问时,PG_active 置为1,加入到活动链表
  • 当页面再次被访问时,PG_referenced 置为1,此时如果页面在非活动链表,则将其移动到活动链表,并将PG_active置为1,PG_referenced 置为0
  • 系统中 daemon 会定时扫描活动链表,定时将页面的 PG_referenced 位置为0
  • 系统中 daemon 定时检查页面的 PG_referenced,如果 PG_referenced=0,那么将此页面的 PG_active 置为0,同时将页面移动到非活动链表5 J( I, n* ^2 D( f: ^$ `

( G: e- N, U, c
7 u, [  L' h9 o7 W2 q# D  `5 [+ m5 g8 l) M0 Y; M) @6 F
2. 页高速缓存
, K' Q+ v$ E) e: N  O
- d( ~/ }& K; t6 |7 ~故名思义,页高速缓存中缓存的最小单元就是内存页。' ~; `( C% G# Z7 r, W+ {& W
! y' W3 |8 I9 h* h+ r$ F, E
但是此内存页对应的数据不仅仅是文件系统的数据,可以是任何基于页的对象,包括各种类型的文件和内存映射。
6 R! H+ f4 w, s% w' |( @4 R2 s- ^5 O% x$ {* {2 [

; T! C, N! M: w5 U3 e6 u+ }% V$ s( k  @. y
2.1 简介/ i, y& S- {  s3 v9 |! |

& I) `- _0 N7 c9 g* f; d页高速缓存缓存的是具体的物理页面,与前面章节中提到的虚拟内存空间(vm_area_struct)不同,假设有进程创建了多个 vm_area_struct 都指向同一个文件,
% I8 I! ^+ s9 R6 ^! i3 [  s. i
9 D0 A/ C6 B# @) X* v那么这个 vm_area_struct 对应的 页高速缓存只有一份。4 k/ o/ S/ O2 P6 {

& r3 q6 N) A4 c' \也就是磁盘上的文件缓存到内存后,它的虚拟内存地址可以有多个,但是物理内存地址却只能有一个。. a3 ~8 O) t& x: t6 ?

- g( z# P% q2 b
8 O3 \: ~* K  ]
1 L2 w  M2 g8 X1 [; P. n. u, b为了有效提高I/O性能,页高速缓存要需要满足以下条件:# ~* l- o. `0 ^( B& T9 O' H
$ |' D4 Y! z3 F' i. R4 u: ~8 \  g
  • 能够快速检索需要的内存页是否存在
  • 能够快速定位 脏页面(也就是被写过,但还没有同步到磁盘上的数据)
  • 页高速缓存被并发访问时,尽量减少并发锁带来的性能损失
    / |4 P0 R" n) O4 T  n8 P

. x! ?6 d$ Z8 X+ v# T) p
  ?6 R' n9 l, U) R下面通过分析内核中的相应的结构体,来了解内核是如何提高 I/O性能的。$ y; T1 |; S4 Z- _* K1 o' F) W2 K

& l3 P4 M! B5 \4 T; L5 @
6 h5 q3 Q) [) I& S
2 @/ I" F% _0 C4 P! W* D2.2 实现
% S( c5 K; Z* c8 _, f* Q' r, T9 F1 r0 y8 e* C1 k1 n
实现页高速缓存的最重要的结构体要算是 address_space ,在 <linux/fs.h> 中
8 R* O, L$ Z" r* B: r2 t# E1 f6 P
  • struct address_space {
  •     struct inode        *host;        /* 拥有此 address_space 的inode对象 */
  •     struct radix_tree_root    page_tree;    /* 包含全部页面的 radix 树 */
  •     spinlock_t        tree_lock;    /* 保护 radix 树的自旋锁 */
  •     unsigned int        i_mmap_writable;/* VM_SHARED 计数 */
  •     struct prio_tree_root    i_mmap;        /* 私有映射链表的树 */
  •     struct list_head    i_mmap_nonlinear;/* VM_NONLINEAR 链表 */
  •     spinlock_t        i_mmap_lock;    /* 保护 i_map 的自旋锁 */
  •     unsigned int        truncate_count;    /* 截断计数 */
  •     unsigned long        nrpages;    /* 总页数 */
  •     pgoff_t            writeback_index;/* 回写的起始偏移 */
  •     const struct address_space_operations *a_ops;    /* address_space 的操作表 */
  •     unsigned long        flags;        /* gfp_mask 掩码与错误标识 */
  •     struct backing_dev_info *backing_dev_info; /* 预读信息 */
  •     spinlock_t        private_lock;    /* 私有 address_space 自旋锁 */
  •     struct list_head    private_list;    /* 私有 address_space 链表 */
  •     struct address_space    *assoc_mapping;    /* 缓冲 */
  •     struct mutex        unmap_mutex;    /* 保护未映射页的 mutux 锁 */
  • } __attribute__((aligned(sizeof(long))));
    % Q& H' @: O  i1 `; ~8 ~. u

1 J* H8 o% r7 o2 D0 y- B" L
8 q+ D) U& t- M5 Y$ |1 o- D% r7 V& T4 f4 e) R
补充说明:5 `: k8 W. M0 U( r, ?5 i1 Y; U

9 o) K8 I* f$ X2 N8 I0 W' `
  • inode - 如果 address_space 是由不带inode的文件系统中的文件映射的话,此字段为 null
  • page_tree - 这个树结构很重要,它保证了页高速缓存中数据能被快速检索到,脏页面能够快速定位。
  • i_mmap - 根据 vm_area_struct,能够快速的找到关联的缓存文件(即 address_space),前面提到过, address_space 和 vm_area_struct 是 一对多的关系。
  • 其他字段主要是提供各种锁和辅助功能: j( g# B: O1 F$ A1 O

6 c+ s& y7 Q; b9 `" ~6 e0 X8 e4 W0 ~: X6 P) L9 n3 {3 p$ L/ y* o3 D
此外,对于这里出现的一种新的数据结构 radix 树,进行简要的说明。
4 _" T7 c" o! C+ @5 Q- r1 w' J2 D; z) ~& e! {9 W3 r! M
radix树通过long型的位操作来查询各个节点, 存储效率高,并且可以快速查询。' y2 ]/ g9 ]3 m3 A
# P2 b' M' [5 R; U
linux中 radix树相关的内容参见: include/linux/radix-tree.h 和 lib/radix-tree.c
( N2 ?0 b2 }& p" x0 c. A& v+ _5 g; E! I9 ^9 ~. e: U
下面根据我自己的理解,简单的说明一下radix树结构及原理。
4 N9 V# J* I  q: A
% ?# {$ G# g5 c  \
8 c1 m) w* S6 M9 {$ @! c. Q
9 m5 I2 {$ t$ H+ e% ]2.2.1 首先是 radix树节点的定义. o+ v! R, T; s9 p7 K1 R
+ Y% e& ]. F+ |- A+ K
  • /* 源码参照 lib/radix-tree.c */
  • struct radix_tree_node {
  •     unsigned int    height;        /* radix树的高度 */
  •     unsigned int    count;      /* 当前节点的子节点数目 */
  •     struct rcu_head    rcu_head;   /* RCU 回调函数链表 */
  •     void        *slots[RADIX_TREE_MAP_SIZE]; /* 节点中的slot数组 */
  •     unsigned long    tags[RADIX_TREE_MAX_TAGS][RADIX_TREE_TAG_LONGS]; /* slot标签 */
  • };# t" v  F* H& {, f  ?6 `& N

  E4 A* r# n  D6 Z  g$ j* F7 ?$ h8 q6 ?0 N
9 K5 w: s; A$ |4 ^3 `) R
弄清楚 radix_tree_node 中各个字段的含义,也就差不多知道 radix树是怎么一回事了。
1 X; ~- M4 a: t3 ]/ k
; g/ d2 X2 e( W- R+ Z
  • height   表示的整个 radix树的高度(即叶子节点到树根的高度), 不是当前节点到树根的高度
  • count    这个比较好理解,表示当前节点的子节点个数,叶子节点的 count=0
  • rcu_head RCU发生时触发的回调函数链表
  • slots    每个slot对应一个子节点(叶子节点)
  • tags     标记子节点是否 dirty 或者 wirteback# Z, T6 [# r; ]) c2 l! z  ]
' C7 u6 w/ L( j- j+ L

& L+ I9 |8 x, ~6 J& O& J2.2.2 每个叶子节点指向文件内相应偏移所对应的缓存页; P/ K7 q& j9 Q% t
9 ^$ e  o) s/ [8 S! Q6 M
比如下图表示 0x000000 至 0x11111111 的偏移范围,树的高度为4 (图是网上找的,不是自己画的)4 `$ r& }% v1 C7 W+ V2 K

8 k) n. L8 o8 L* I- G" Q- }+ w ) D  g6 u5 T, ]& K" g/ p  |; T

) [, h; Y" T0 S2 P% ` & K8 o* D6 }0 c- S; s2 c
4 U0 Z4 `6 ~9 i  l7 ~2 W( A
2.2.3 radix tree 的叶子节点都对应一个二进制的整数,不是字符串,所以进行比较的时候非常快
2 h8 M' K, o- S2 Q- m) A8 Q' A! J2 @, r) H- k
其实叶子节点的值就是地址空间的值(一般是long型)
; w5 J- G7 ?( i8 I& {( S: a4 H) ^( ]5 c2 p4 s4 t

+ g4 R3 {) k3 @" K, D
& _; Y6 F2 o2 ]2 o( c3. 页回写
+ c; C2 r4 \5 L" s- a$ y3 l8 y. D/ }3 C
由于目前linux内核中对于「写缓存」采用的是第3种策略,所以回写的时机就显得非常重要,回写太频繁影响性能,回写太少容易造成数据丢失。# f# \+ y- X' _$ i* A1 w' n! R
8 U; T7 _8 P* U% l$ ^4 k; Z4 ^

  J: ^# H) S- x$ \5 {: F5 A/ H
' l# n; n& r1 n* z# c* f3.1 简介/ l- f" e+ v* \$ F! Y
) I' g$ P; e1 K, W/ ]
linux 页高速缓存中的回写是由内核中的一个线程(flusher 线程)来完成的,flusher 线程在以下3种情况发生时,触发回写操作。: V# y( Q2 R8 w
/ u8 V; \! Y/ C4 |
1. 当空闲内存低于一个阀值时  S9 X% ^5 ~% Y4 V) B" R

6 l, e" i. H, i" \. B! u. m    空闲内存不足时,需要释放一部分缓存,由于只有不脏的页面才能被释放,所以要把脏页面都回写到磁盘,使其变成干净的页面。
& P3 p0 R6 F; a- D" V
/ T9 G& B* X+ K+ H* |! r( n2. 当脏页在内存中驻留时间超过一个阀值时
- H+ B0 z) p0 _) U
' B- S4 i) P0 J$ J   确保脏页面不会无限期的驻留在内存中,从而减少了数据丢失的风险。) W) K3 F" ]. ^

" v( U; ?4 I8 Z+ a% \2 g4 }3. 当用户进程调用 sync() 和 fsync() 系统调用时% @! j( |. R9 E9 r

( V; V* M3 o) V2 I5 t9 \; y   给用户提供一种强制回写的方法,应对回写要求严格的场景。
: o6 q2 x5 v9 o  D& Z3 U+ W" M% C
6 C" L' c) T1 Z1 p1 J8 Y) w - E9 I- s5 E) ?4 Z5 i

# l( a- k; O4 A) g  D: f+ z页回写中涉及的一些阀值可以在 /proc/sys/vm 中找到8 F0 L! g3 j2 J5 ~6 C) W+ S
& O8 O/ d0 U; D4 t
下表中列出的是与 pdflush(flusher 线程的一种实现) 相关的一些阀值
9 d- ^/ w1 H- \) r; P3 a5 v2 A8 o4 W
阀值
描述
dirty_background_ratio占全部内存的百分比,当内存中的空闲页达到这个比例时,pdflush线程开始回写脏页
dirty_expire_interval该数值以百分之一秒为单位,它描述超时多久的数据将被周期性执行的pdflush线程写出
dirty_ratio占全部内存的百分比,当一个进程产生的脏页达到这个比例时,就开始被写出
dirty_writeback_interval该数值以百分之一秒未单位,它描述pdflush线程的运行频率
laptop_mode一个布尔值,用于控制膝上型计算机模式

3 U2 W. M0 g( v
" V( j8 g4 N" y9 k5 ]/ ^% Y" H; F1 B: B* p! W/ @+ t" @2 X4 _7 L
3.2 实现
- R; e% K, O' i7 j$ G9 f" \. Z% r2 j% M! M* ~: a9 V! h
flusher线程的实现方法随着内核的发展也在不断的变化着。下面介绍几种在内核发展中出现的比较典型的实现方法。: `* V# V: I* i. L% j: c$ _) q

4 U  ]+ k" B4 R$ s5 |3 W1 R5 E# E1. 膝上型计算机模式
: D  R0 ]0 m8 n6 R- y4 [+ w- W  A! G' [+ T# y9 q
这种模式的意图是将硬盘转动的机械行为最小化,允许硬盘尽可能长时间的停滞,以此延长电池供电时间。
$ U8 G0 s5 x3 i0 z0 s% a0 M( c7 ~4 c" F7 T% D
该模式通过 /proc/sys/vm/laptop_mode 文件来设置。(0 - 关闭该模式  1 - 开启该模式)$ V8 n1 W' s  E- e  L4 L4 {, i# y
7 [- b' {2 ?/ a! o% s" ^6 \% O
! w) M# U  H7 D% @. w' L- [
! h* y! D) x1 g% q5 E
2. bdflush 和 kupdated (2.6版本前 flusher 线程的实现方法)
4 o" `3 ~) {2 R2 U% s' W7 `
+ v, W( |# r3 N4 B/ d: C! Y$ ]bdflush 内核线程在后台运行,系统中只有一个 bdflush 线程,当内存消耗到特定阀值以下时,bdflush 线程被唤醒
, M( ]: e2 V, W
+ c( Q9 U, B4 g$ Gkupdated 周期性的运行,写回脏页。5 D2 y8 q9 F. B/ O( ^/ W
. f( Y; f6 _! V9 v- i) X- r. T
# [8 n& P' c7 {

& K  m+ b- y/ P" `, W% Sbdflush 存在的问题:6 r9 M! P: t% P, w# T$ a; k1 i, K4 g! g
. b' Y6 n/ l* A* u( t1 l0 X
整个系统仅仅只有一个 bdflush 线程,当系统回写任务较重时,bdflush 线程可能会阻塞在某个磁盘的I/O上,
5 T- m+ T6 @9 L8 n- H/ s
" R5 p( }8 r! p! z/ V# `* E导致其他磁盘的I/O回写操作不能及时执行。/ p  b% b8 Z3 o0 e1 s  A
. \5 a$ h8 w; F; e: S$ ?  k5 `, w

; i* F& {% ~( m% t( r0 c2 O4 E/ E& n; H
3. pdflush (2.6版本引入)+ t& }- w- p6 j. o

1 S  a) E9 c+ xpdflush 线程数目是动态的,取决于系统的I/O负载。它是面向系统中所有磁盘的全局任务的。
2 P" c6 ^( x- l1 w8 c
. [5 r. X8 a# V* K& `: o
2 F6 e6 J7 O, ~; l
% \% g1 Y" l( e* l8 n$ |5 @. [1 opdflush 存在的问题:; b. q0 d! h) K$ y0 ?
8 y1 _( A& {# |6 j
pdflush的数目是动态的,一定程度上缓解了 bdflush 的问题。但是由于 pdflush 是面向所有磁盘的,
9 k/ {4 Z8 j6 T
6 y; ~2 z. ?- E0 C5 V: Z, r$ w$ ]4 G所以有可能出现多个 pdflush 线程全部阻塞在某个拥塞的磁盘上,同样导致其他磁盘的I/O回写不能及时执行。9 G' Q1 |8 v6 }  a" x0 L
# v/ f0 }" v/ W. C/ n" c
2 h- P/ _; S0 ~2 v9 _* E
8 k5 Q! ~  f1 Y/ y% w# C2 ?7 k- j' t
4. flusher线程 (2.6.32版本后引入)
7 ?( ]* M7 B/ F# W0 c1 U6 d. ^8 q2 Z- b0 _5 d0 J# J
flusher线程改善了上面出现的问题:
. W6 _, L& c3 S- r2 I3 G8 I% _# l* y1 Q$ V% |
首先,flusher 线程的数目不是唯一的,这就避免了 bdflush 线程的问题
: D& x+ s% d; Z4 D6 W# s( u, p; C* ]3 p2 d; G
其次,flusher 线程不是面向所有磁盘的,而是每个 flusher 线程对应一个磁盘,这就避免了 pdflush 线程的问题
1 I) z4 f2 e5 ~. @) d

该用户从未签到

2#
发表于 2021-2-19 13:11 | 只看该作者
Linux内核设计与实现之页高速缓存和页回写
您需要登录后才可以回帖 登录 | 注册

本版积分规则

关闭

推荐内容上一条 /1 下一条

EDA365公众号

关于我们|手机版|EDA365电子论坛网 ( 粤ICP备18020198号-1 )

GMT+8, 2025-11-24 22:11 , Processed in 0.156250 second(s), 26 queries , Gzip On.

深圳市墨知创新科技有限公司

地址:深圳市南山区科技生态园2栋A座805 电话:19926409050

快速回复 返回顶部 返回列表