|
|
EDA365欢迎您登录!
您需要 登录 才可以下载或查看,没有帐号?注册
x
7 W# n9 g+ E9 _2 {! p主要内容:8 ?1 W+ D) Y/ x' n" ~% g) O
+ Q; a: z& A7 b+ o8 T
- 缓存简介
- 页高速缓存
- 页回写
2 v8 ~! |* m6 X3 U4 b2 @
" \1 o- R+ ~4 X6 i
* ]* j9 `6 `& [& |, r: r8 L1. 缓存简介. [: U/ d, @/ R! L. Q) Z
在编程中,缓存是很常见也很有效的一种提高程序性能的机制。
" `4 j9 A# ]- r ~
# j) u C% l9 nlinux内核也不例外,为了提高I/O性能,也引入了缓存机制,即将一部分磁盘上的数据缓存到内存中。( V( U4 j! w: I
! _9 {/ {) ]" l' O! n + N4 L; d- N% y* o3 P* @8 o O
, U& e& H: z$ `) B1.1 原理
6 E2 T( p+ i% \ {, U- u2 V+ q' q& z( x; `. x/ A; `
之所以通过缓存能提高I/O性能是基于以下2个重要的原理:2 b- K$ z9 q% ?# u1 k2 l Y
2 p2 I8 v# N2 U1 o- l. N2 h- CPU访问内存的速度远远大于访问磁盘的速度(访问速度差距不是一般的大,差好几个数量级)
- 数据一旦被访问,就有可能在短期内再次被访问(临时局部原理)
/ ^( f0 a3 x1 v8 c( _ 4 U- L8 W7 o+ a1 E$ @7 S7 H( |; ^9 O! ^
" ]7 J3 s7 G. h3 @; K; _
1.2 策略
7 S, K4 a: x' q2 V
8 F1 q1 M N: a3 `1 R缓存的创建和读取没什么好说的,无非就是检查缓存是否存在要创建或者要读取的内容。5 A' V, G6 a: N$ ^2 J. r
' D; ?% t8 Y) B1 H) Y1 l2 u
但是写缓存和缓存回收就需要好好考虑了,这里面涉及到「缓存内容」和「磁盘内容」同步的问题。$ y( b" B! L: N
) s2 N' g8 z. j4 e' R1.2.1 「写缓存」常见的有3种策略8 k0 j3 }1 g7 ^
: i- m; b' m( B( Z; g- 不缓存(nowrite) :: 也就是不缓存写操作,当对缓存中的数据进行写操作时,直接写入磁盘,同时使此数据的缓存失效
- 写透缓存(write-through) :: 写数据时同时更新磁盘和缓存
- 回写(copy-write or write-behind) :: 写数据时直接写到缓存,由另外的进程(回写进程)在合适的时候将数据同步到磁盘/ A, }+ H4 K6 R7 v# s5 Y, ]
& p1 C0 m3 q& n# q0 }9 M
9 v5 |% n! v7 h5 g
3种策略的优缺点如下:! R# R" O0 H- b) r3 r+ g
9 Z# K0 ?6 [" G1 p
策略 | 复杂度 | 性能 | | 不缓存 | 简单 | 缓存只用于读,对于写操作较多的I/O,性能反而会下降 | | 写透缓存 | 简单 | 提升了读性能,写性能反而有些下降(除了写磁盘,还要写缓存) | | 回写 | 复杂 | 读写的性能都有提高(目前内核中采用的方法) |
8 h6 H1 a1 K5 j& F8 K$ k3 V% d( d
- }: G0 y+ r* @( g$ L$ M' I# l# v
( ^! T3 r0 y( F7 t. Q, i8 `$ @0 V) z1.2.2 「缓存回收」的策略7 _+ G q1 @- k# {' ~3 u
8 P, _' W3 n# X# X- 最近最少使用(LRU) :: 每个缓存数据都有个时间戳,保存最近被访问的时间。回收缓存时首先回收时间戳较旧的数据。
- 双链策略(LRU/2) :: 基于LRU的改善策略。具体参见下面的补充说明* Q! y7 {# w, M* e/ a+ \
9 g2 o" _; W8 ]" u6 W$ A
8 ~/ p6 N6 V" d( L8 b
补充说明(双链策略):
1 B* q4 s9 n0 T3 n1 A% f
. C. x3 ], ?4 G: Y9 ~双链策略其实就是 LRU(Least Recently Used) 算法的改进版。& D! E+ k5 o& T+ M8 t; O; Y8 d
) }# I, M6 n: ~, O' F; w) v6 L6 d6 J它通过2个链表(活跃链表和非活跃链表)来模拟LRU的过程,目的是为了提高页面回收的性能。
( \; H$ O0 T9 u# A6 n. e3 T& E4 m: `) B) }; C( x& Y
页面回收动作发生时,从非活跃链表的尾部开始回收页面。- v5 n3 m. U" f- I" [
: G8 h H/ K8 q( P$ L. G A $ W& a2 m4 a1 Q* F
' e, B, m# q0 j0 `6 h' o/ o
双链策略的关键就是页面如何在2个链表之间移动的。
, A* Y& q: I9 q$ W+ n. c. h, a
6 J/ g7 t% p/ g" m: H双链策略中,每个页面都有2个标志位,分别为
7 S# S! [% ]2 L- C4 A' o+ W* O7 _ ~9 U1 E9 O5 }" A
PG_active - 标志页面是否活跃,也就是表示此页面是否要移动到活跃链表& j% J Q3 [' V h5 a& ]
0 ?+ D5 F7 {1 l T) @3 x1 W
PG_referenced - 表示页面是否被进程访问到
$ t' Z" x/ j& y3 D# c/ \. B' O1 [( L1 w
! X$ q4 }. ]3 Z' j8 H' c! p, ~
: A0 y6 Y7 k4 a, @3 a; s1 a页面移动的流程如下:
5 e# ]- a0 P% _1 k! g& w; A1 @* u/ ]/ r% s3 }- P/ P3 P. ~5 W6 c& E
- 当页面第一次被被访问时,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,同时将页面移动到非活动链表$ z* \# z" G) @/ M W( _1 Z
% |' [0 U8 i# c
* E3 B6 D/ T! p# T/ u' P) R: g7 J$ e
" G; L1 f c( k! i* m; _" I( j" x* B
2. 页高速缓存
- Q7 A- F7 R' Q7 n; Y5 }1 Q6 e0 a5 W' L/ b7 ~& X
故名思义,页高速缓存中缓存的最小单元就是内存页。
+ k+ K$ E0 Y( `% m- M5 G
+ q4 ^; i8 |) `. H r7 t( a) U4 v但是此内存页对应的数据不仅仅是文件系统的数据,可以是任何基于页的对象,包括各种类型的文件和内存映射。% V: t- d# J% y- D
) S/ ?0 a- i0 L2 v* o( [6 N3 \& i
3 U; r3 E/ y: z/ T. f, T( y" ~8 d5 f0 K$ W% s5 e- A; A& l$ s
2.1 简介) Y* o1 A1 N1 K% x- d$ Y% ^/ ~9 x
/ \9 E2 R" G3 G' g6 z! Z页高速缓存缓存的是具体的物理页面,与前面章节中提到的虚拟内存空间(vm_area_struct)不同,假设有进程创建了多个 vm_area_struct 都指向同一个文件,
+ C/ T3 l) D, ^, `$ b
: K+ ]/ @4 S- L( Q& L4 r那么这个 vm_area_struct 对应的 页高速缓存只有一份。
, y2 d% h1 r) r9 D6 K8 H! Q4 o7 N5 Y: w7 I/ b
也就是磁盘上的文件缓存到内存后,它的虚拟内存地址可以有多个,但是物理内存地址却只能有一个。* |% u3 V2 }% X* @+ R ]
' e9 g$ N0 J. F; A- ]: N5 f& W" C
" J. d L9 F) v+ x6 Z7 M. A3 Q; F* Y( m7 Y, ~: k4 e9 |/ a
为了有效提高I/O性能,页高速缓存要需要满足以下条件:$ J, ]4 _! n- @' D- \: U
- \" J. r0 ?3 ~# x& a1 ^' S) x' _
- 能够快速检索需要的内存页是否存在
- 能够快速定位 脏页面(也就是被写过,但还没有同步到磁盘上的数据)
- 页高速缓存被并发访问时,尽量减少并发锁带来的性能损失
9 u2 K5 Y1 r0 \9 e2 R9 E / x0 \$ d, f$ ]6 u$ v$ Z2 n, b
- F: w; x2 C8 U
下面通过分析内核中的相应的结构体,来了解内核是如何提高 I/O性能的。
3 V# d2 T |; _+ t9 ^0 I U0 ]1 B1 W
" G! u) R, Y3 i" H
) q( `' L# p3 n; e N: l, y2.2 实现5 w) X+ T' E! i$ I1 J
7 u7 G5 b& c& n2 s$ {6 ?
实现页高速缓存的最重要的结构体要算是 address_space ,在 <linux/fs.h> 中3 f, G; @, v( o& I5 ^
% T* W! a8 k( J# R; d. 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))));
; @: N0 Q, x5 K i2 a$ }+ J . K5 l4 v: R- r: S% \
3 F' w* R% A/ M1 P6 o% }2 U7 `2 e
; o7 d ?9 x1 `9 [
补充说明:3 P* T8 Z$ h( o `+ T) r, o' A; a+ }
6 O8 Y# A8 @: F! Y p- inode - 如果 address_space 是由不带inode的文件系统中的文件映射的话,此字段为 null
- page_tree - 这个树结构很重要,它保证了页高速缓存中数据能被快速检索到,脏页面能够快速定位。
- i_mmap - 根据 vm_area_struct,能够快速的找到关联的缓存文件(即 address_space),前面提到过, address_space 和 vm_area_struct 是 一对多的关系。
- 其他字段主要是提供各种锁和辅助功能4 m6 h' V/ k# A$ m
# ?- @: w% Q: A: s+ x1 J
" U7 b4 q" e& q# n9 I此外,对于这里出现的一种新的数据结构 radix 树,进行简要的说明。, p6 g4 t* O3 f% N0 t% @$ S5 M
- F) e3 a: i0 A& A& B+ m
radix树通过long型的位操作来查询各个节点, 存储效率高,并且可以快速查询。
2 \' i+ L) g: P" p( o$ p8 p9 o1 f2 ?+ `- C" Z
linux中 radix树相关的内容参见: include/linux/radix-tree.h 和 lib/radix-tree.c
: }$ b% e( g+ ]/ p# Q" ~
+ r+ f6 I: T! ^. T* B- q) I* N下面根据我自己的理解,简单的说明一下radix树结构及原理。6 O# s+ ^. ^* ~ o( M
/ ~- j+ R9 ?4 X, C; O1 o1 b
( [. F0 E! X8 }) u' W4 o
9 C4 S: z+ }& }! c3 T$ e" e
2.2.1 首先是 radix树节点的定义
$ T3 D0 b7 X4 t5 b% o3 [1 }: _& W" K+ Q
- /* 源码参照 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标签 */
- };* g* q- ?& u4 r# f8 g6 \5 m+ c
' _% f3 U4 L* [! f% V! r' B" F% x. p# x+ c- q
! K$ U9 K! U* R4 a3 U$ u' Z. R弄清楚 radix_tree_node 中各个字段的含义,也就差不多知道 radix树是怎么一回事了。
7 H( ^2 m/ Q5 S I8 n6 w# X/ |/ T! c3 I. ~+ S( T3 A y9 f" z8 A( ^$ j0 l
- height 表示的整个 radix树的高度(即叶子节点到树根的高度), 不是当前节点到树根的高度
- count 这个比较好理解,表示当前节点的子节点个数,叶子节点的 count=0
- rcu_head RCU发生时触发的回调函数链表
- slots 每个slot对应一个子节点(叶子节点)
- tags 标记子节点是否 dirty 或者 wirteback
0 y* o$ f5 z. m+ i3 F+ P1 T
6 u- x3 _& Z7 O7 J6 r( G3 Z* t8 E
! s. P; W+ K0 }- G) T9 U7 I2.2.2 每个叶子节点指向文件内相应偏移所对应的缓存页
: |9 T6 S* g1 q3 [$ r- {3 a/ k0 V5 ]$ u6 P' X: q5 f; ]& |
比如下图表示 0x000000 至 0x11111111 的偏移范围,树的高度为4 (图是网上找的,不是自己画的)" [# T$ Q, ~4 C5 g
) S! ]* O: k& s% r8 B% c3 D M- j5 q
: s0 G& F6 B, [2 |7 H$ ]
# J- u& ^7 f7 N$ S) l( E1 C% k! Y . U- h4 {* Y: F" e
Q7 p; V4 E% D1 r0 F$ D
2.2.3 radix tree 的叶子节点都对应一个二进制的整数,不是字符串,所以进行比较的时候非常快8 ]2 i% G1 ]' ^5 c! S
& I- t! G7 c2 i% ?7 }/ _+ M
其实叶子节点的值就是地址空间的值(一般是long型)5 h0 h, a7 a5 ?- a2 d
' J+ l1 {- ^4 S3 w8 r
1 @3 U P/ _4 k' R1 C
' h/ V* n0 j9 L$ M+ B3. 页回写 R" ~3 {0 e* E. _
, R: M& a. R/ a由于目前linux内核中对于「写缓存」采用的是第3种策略,所以回写的时机就显得非常重要,回写太频繁影响性能,回写太少容易造成数据丢失。/ \. q0 a0 t- D' U- D0 h) K
% g/ J N* T4 f1 D1 w
2 U k5 Y) y* B$ p9 U1 ^5 y ?4 f, f8 g9 l' ?7 A0 z* z2 L6 b1 a. b
3.1 简介
0 l! {0 a- R: @4 x4 _) S, c4 {& d' y5 @. @# Y
linux 页高速缓存中的回写是由内核中的一个线程(flusher 线程)来完成的,flusher 线程在以下3种情况发生时,触发回写操作。
' N: V: x9 N, k) `( H/ v
: f- z* d) v1 z$ n8 H8 C! _1. 当空闲内存低于一个阀值时8 O# T: o" |# a; m- p+ [' q8 }8 k
L" b$ \# c; |1 T. {1 t 空闲内存不足时,需要释放一部分缓存,由于只有不脏的页面才能被释放,所以要把脏页面都回写到磁盘,使其变成干净的页面。
2 j" V( _& [$ n0 P/ l3 R1 ]7 i
0 q% H1 s0 r& k" v3 _2. 当脏页在内存中驻留时间超过一个阀值时, V6 M; U: i3 M; k' {
' {4 B: H2 g0 ]" ] 确保脏页面不会无限期的驻留在内存中,从而减少了数据丢失的风险。
: [, N8 Y0 J1 O, F/ G: F& {
$ P* C) N2 g2 x: \5 ~" e2 D3. 当用户进程调用 sync() 和 fsync() 系统调用时: b! A. l" K' g. B2 d4 Z; N7 s# q8 f
g) S0 D8 v7 X8 d
给用户提供一种强制回写的方法,应对回写要求严格的场景。
! w: W% Y4 y6 t: ?7 u# X( ?
, @1 T5 l3 [+ k2 i0 L8 j$ ~0 b
! O. q& M k3 z! c/ o
6 x! ?7 D. i2 [/ V/ x) m页回写中涉及的一些阀值可以在 /proc/sys/vm 中找到
0 O' U* C) I) ?8 q) K2 ], k+ w; m ~8 Q/ R$ e
下表中列出的是与 pdflush(flusher 线程的一种实现) 相关的一些阀值2 q: }* l* H' u$ q. N: m2 T! E3 c
# }) g+ q* M* I
阀值 | 描述 | | dirty_background_ratio | 占全部内存的百分比,当内存中的空闲页达到这个比例时,pdflush线程开始回写脏页 | | dirty_expire_interval | 该数值以百分之一秒为单位,它描述超时多久的数据将被周期性执行的pdflush线程写出 | | dirty_ratio | 占全部内存的百分比,当一个进程产生的脏页达到这个比例时,就开始被写出 | | dirty_writeback_interval | 该数值以百分之一秒未单位,它描述pdflush线程的运行频率 | | laptop_mode | 一个布尔值,用于控制膝上型计算机模式 |
: }- V7 C3 V2 {; z7 Z J" M
4 q+ V$ S" K$ G% `
+ g: E! U2 x1 e3.2 实现% ]& z2 ~+ v4 d" j2 y0 E" k
! W5 _% g& c* n$ H7 E
flusher线程的实现方法随着内核的发展也在不断的变化着。下面介绍几种在内核发展中出现的比较典型的实现方法。# U5 j* s# C8 {) a6 Y w
' y1 L9 G! s- W* W$ c3 r. I: {( O$ g3 P1. 膝上型计算机模式2 G6 e5 L" z, q! [# b, |& n5 F
& ~; A1 p1 \1 W4 j$ S4 i
这种模式的意图是将硬盘转动的机械行为最小化,允许硬盘尽可能长时间的停滞,以此延长电池供电时间。% [4 U8 l( I n P B% c
/ F* u8 T$ l& B该模式通过 /proc/sys/vm/laptop_mode 文件来设置。(0 - 关闭该模式 1 - 开启该模式): d2 G) {% D0 c! b
- x) `/ ?. T9 C
# s8 d* A2 k. B3 ?! r
0 o/ k. c. x7 P0 y! c2. bdflush 和 kupdated (2.6版本前 flusher 线程的实现方法)5 F! {4 d. W5 D% ?/ t7 \
+ b! o. V h- @( `0 A0 N. a
bdflush 内核线程在后台运行,系统中只有一个 bdflush 线程,当内存消耗到特定阀值以下时,bdflush 线程被唤醒4 q" s" k/ ^' ?! [
# y8 C! ^8 L0 v `/ Fkupdated 周期性的运行,写回脏页。
7 V' `- ^1 v& Z- C5 m0 R7 r3 ^, m2 F3 W( {
7 G& Y1 C! ]9 [7 S
2 B1 M% @4 n( `8 k! v
bdflush 存在的问题:
; ?$ [- [: k$ O W) q s @) l4 |6 O+ u! U# |% m; m
整个系统仅仅只有一个 bdflush 线程,当系统回写任务较重时,bdflush 线程可能会阻塞在某个磁盘的I/O上,' x- ]- C" V$ _* }4 ?. B# r
3 J/ j2 ^+ P& }* [- E1 ~& w; ~" q导致其他磁盘的I/O回写操作不能及时执行。- h7 k# A0 C. Q" V- W' ~) W
: P6 c6 y' n0 A: T* n, Y! O
5 M' M6 C5 o) j) l& I# T
# T- {0 K, e/ x4 o3. pdflush (2.6版本引入)
8 J1 d- i: `1 }$ W$ m! ]
4 q& D7 |: V$ Xpdflush 线程数目是动态的,取决于系统的I/O负载。它是面向系统中所有磁盘的全局任务的。
& V4 k) h- D6 ~% }/ W) V/ p& \% ]% l+ e6 i9 [9 M- r. e1 O3 I; K( d+ M; a
$ ^3 x* T( c8 @9 [2 r! {. e1 _
5 c6 Q+ Z0 b+ M9 `9 g0 b% Fpdflush 存在的问题:
2 y3 g+ H' o# A/ U9 H: I, ~7 c# e- i, ]: Y% E4 ]
pdflush的数目是动态的,一定程度上缓解了 bdflush 的问题。但是由于 pdflush 是面向所有磁盘的,& q6 g9 W9 P. e- }1 B+ s5 ^
$ b) Z( e" a7 v9 W9 I+ h' g% h
所以有可能出现多个 pdflush 线程全部阻塞在某个拥塞的磁盘上,同样导致其他磁盘的I/O回写不能及时执行。7 K# |* n8 _% o7 O$ G# r
! E, q+ h: g- L9 z0 u
% m( J1 Q/ f4 a$ q4 O# L/ \
) ^" O7 U! E8 W" Y. B+ {' I! L4. flusher线程 (2.6.32版本后引入)& F, H- R7 i6 Y: g
+ |- d3 b+ {# y; e" B7 y3 I
flusher线程改善了上面出现的问题:
' z4 x+ |1 Z2 P/ c1 x# R* a7 A4 C% I* {
首先,flusher 线程的数目不是唯一的,这就避免了 bdflush 线程的问题/ ^6 G- {; a1 C: U
" H6 Q; h# ?1 v$ I7 h$ U* l
其次,flusher 线程不是面向所有磁盘的,而是每个 flusher 线程对应一个磁盘,这就避免了 pdflush 线程的问题
/ f/ c- B1 _( i4 q4 h0 B# R |
|