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

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

[复制链接]

该用户从未签到

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

EDA365欢迎您登录!

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

x

) }& G" O% L3 D  X主要内容:+ `/ ], D& H9 J
/ Y# H9 _1 |+ A1 Q& T' a
  • 缓存简介
  • 页高速缓存
  • 页回写1 _5 S/ C0 l9 e

* J. ?5 v. h0 @& @) e
5 ]+ c, U! w; s, G1. 缓存简介+ ~& U7 o3 [6 F) f) {1 T3 ]
在编程中,缓存是很常见也很有效的一种提高程序性能的机制。- w8 m5 r5 X0 S, }$ s
$ u/ \; M- Q/ _6 a" n- \* s
linux内核也不例外,为了提高I/O性能,也引入了缓存机制,即将一部分磁盘上的数据缓存到内存中。
) b. h5 a! j1 i: M: [, p( N6 j; W5 `% }  }% I: R7 }

$ N7 Z; w# J- A! J; I5 I7 Z% q1 K, P) M$ \" N
1.1 原理
+ H9 J) H$ t: d. l! U2 w  `  f% O5 L2 I$ c
之所以通过缓存能提高I/O性能是基于以下2个重要的原理:- p4 Y9 W( v+ w/ O) j5 Q/ L' K

, m  }1 b; ^+ U8 M, Q! T% @# [
  • CPU访问内存的速度远远大于访问磁盘的速度(访问速度差距不是一般的大,差好几个数量级)
  • 数据一旦被访问,就有可能在短期内再次被访问(临时局部原理)
      ~/ }8 r% ]- q
; q' r" I2 Q' U7 |7 g: y

5 q% ^! u' ^+ r5 h% t5 s& Z1.2 策略2 s  V+ a% S$ O6 h* ]: d. B
; F3 E& i* g9 P2 K) {& J1 h
缓存的创建和读取没什么好说的,无非就是检查缓存是否存在要创建或者要读取的内容。, I6 h5 n4 g: m- S3 T
+ D# d* G0 @4 I# P# L9 o
但是写缓存和缓存回收就需要好好考虑了,这里面涉及到「缓存内容」和「磁盘内容」同步的问题。+ j( v7 Y* ~0 M4 @4 a8 P
  h4 v" {7 E" G6 B
1.2.1 「写缓存」常见的有3种策略
8 Y. D  @( y/ }, V' [/ S+ j" ~7 B% B; }
  • 不缓存(nowrite) :: 也就是不缓存写操作,当对缓存中的数据进行写操作时,直接写入磁盘,同时使此数据的缓存失效
  • 写透缓存(write-through) :: 写数据时同时更新磁盘和缓存
  • 回写(copy-write or write-behind) :: 写数据时直接写到缓存,由另外的进程(回写进程)在合适的时候将数据同步到磁盘% ]1 G3 J: X! S9 s5 U
( I) E; j" v! U0 ]5 Y, P2 G5 b! M# W

& H$ I; Z5 x4 C: m$ S3种策略的优缺点如下:
; J  k; w8 E0 I" s8 f4 h
" a: @. p+ e7 [; B+ @+ V
策略
复杂度
性能
不缓存简单缓存只用于读,对于写操作较多的I/O,性能反而会下降
写透缓存简单提升了读性能,写性能反而有些下降(除了写磁盘,还要写缓存)
回写复杂读写的性能都有提高(目前内核中采用的方法)

8 D2 [7 l( [/ y" u4 \2 ~# `
9 ?0 N2 C1 ^5 |% {  M! D" `; k% `) e$ \$ z, ^+ e8 M& W" h' y
1.2.2 「缓存回收」的策略0 J) o" E: _- d, S, X* H8 D' m

9 B1 q2 r; F5 \( r
  • 最近最少使用(LRU) :: 每个缓存数据都有个时间戳,保存最近被访问的时间。回收缓存时首先回收时间戳较旧的数据。
  • 双链策略(LRU/2) :: 基于LRU的改善策略。具体参见下面的补充说明- F5 D' e. F% c

3 I, i" |& q6 K$ X3 j5 }$ J
' O$ ?/ n. O+ T8 T1 ?补充说明(双链策略):
5 a- ]) |( \; C) {; h! p9 Z: d* m- ]! S! o; E+ P
双链策略其实就是 LRU(Least Recently Used) 算法的改进版。5 P# |5 q3 [. S' ]1 V% Q$ b
# Q  I7 C7 |: z' [
它通过2个链表(活跃链表和非活跃链表)来模拟LRU的过程,目的是为了提高页面回收的性能。
9 S- I+ n- R; {( Y, Z( I- d! B7 G$ [( X2 A  n/ O7 y1 l
页面回收动作发生时,从非活跃链表的尾部开始回收页面。9 R3 y/ ?! c) k1 h' x6 k5 m, H. X
# `( J9 f# c: [* Y# J$ T
9 C7 H' U" |5 M2 r8 C8 b4 M

5 L( o% ^5 i& E$ ~! X双链策略的关键就是页面如何在2个链表之间移动的。/ a& B( P1 V5 ]; q

6 A3 ?! B% G) n& s$ d4 u" a双链策略中,每个页面都有2个标志位,分别为: M; C2 \. Z. u4 O" O3 _5 _  q

! J6 D# b8 ]/ E" w; tPG_active - 标志页面是否活跃,也就是表示此页面是否要移动到活跃链表
, U  i' }2 N7 O# k, V0 I& ?7 Z! L; F1 Z5 |7 ]9 S( _
PG_referenced - 表示页面是否被进程访问到
! f! c% A* w0 W7 t% c
' c* t2 {9 ?/ e + U& u8 Y  f% L, T; _. Y9 e5 H
! K$ k6 j  e& l6 T
页面移动的流程如下:
4 P4 a) Z1 w: ~4 C2 B- R; [- \
8 L) D' [" Q: o, a; Z
  • 当页面第一次被被访问时,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,同时将页面移动到非活动链表2 S3 r, `8 O! s
9 n4 b0 _7 |' {1 c8 u% D' l
. ~9 d* t. f* e$ q3 U

5 u0 v! B5 c0 R: n5 Y+ m2. 页高速缓存7 `" x4 {8 k1 N6 E

. B6 c0 T3 T, i" s: J故名思义,页高速缓存中缓存的最小单元就是内存页。+ E/ j; |& r1 t2 p7 d
2 o8 B4 Y% B! d2 w' X% Q% ?
但是此内存页对应的数据不仅仅是文件系统的数据,可以是任何基于页的对象,包括各种类型的文件和内存映射。
2 D" n$ P& f* B2 z, ^2 Z$ H" o. {0 d0 h( D+ x& q" y# p! G
  U7 g; I1 B( y: C9 E

4 _# k! M3 a! |+ _* `2.1 简介
' @2 ^  w8 P6 b# M) V3 w. _: T( d7 V1 n& E  O, l+ z: j7 Y! V# \
页高速缓存缓存的是具体的物理页面,与前面章节中提到的虚拟内存空间(vm_area_struct)不同,假设有进程创建了多个 vm_area_struct 都指向同一个文件,
1 u% q7 u! t0 L$ Y) ~6 w4 g
1 m( H' c3 `/ X$ d  i% L( g那么这个 vm_area_struct 对应的 页高速缓存只有一份。/ O! k1 w) _: O. c  y( G1 Y3 O& x
7 q. Y) z4 x  T) k
也就是磁盘上的文件缓存到内存后,它的虚拟内存地址可以有多个,但是物理内存地址却只能有一个。
9 N1 m8 ~' W% x- w! C
$ R1 }; S* P/ V0 I5 c  s  K 0 }4 c* N6 g6 V& [. [3 M( G( F5 x: k- `

6 q8 P: \3 f$ U' m' @# _5 F为了有效提高I/O性能,页高速缓存要需要满足以下条件:6 q& o# A+ E! B9 A, c
! E) @- \) D( D* o& m
  • 能够快速检索需要的内存页是否存在
  • 能够快速定位 脏页面(也就是被写过,但还没有同步到磁盘上的数据)
  • 页高速缓存被并发访问时,尽量减少并发锁带来的性能损失; r2 w5 ~# @  @9 V8 ?
" w+ [' Q; X2 c2 ~9 g' s" ?

0 W$ r2 }! R, f0 F1 n2 y6 ~5 J下面通过分析内核中的相应的结构体,来了解内核是如何提高 I/O性能的。! H& K2 j9 r9 }6 w' g) z0 U

8 E7 T3 W7 ]# s" |( Q9 c 3 X7 C( B, I3 D; m- A5 o9 d9 N

1 }8 a- I3 l  m2.2 实现
& G) V0 R- b! a4 s) C3 ^: H7 D5 t- D; L. B9 q$ u
实现页高速缓存的最重要的结构体要算是 address_space ,在 <linux/fs.h> 中/ |& G( M7 t2 q% d" V0 U3 T0 K

* c; q2 d9 C5 q
  • 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))));
    + i6 K4 P1 X# M/ q: u

) w# h7 V# B. P: Y% P) P
! C2 b/ c9 L3 d6 h- [" J& u  _( c2 G
补充说明:
/ s/ m5 Y5 m# g$ K$ @; }
, [) H& {, V4 S$ F7 r+ N; p
  • inode - 如果 address_space 是由不带inode的文件系统中的文件映射的话,此字段为 null
  • page_tree - 这个树结构很重要,它保证了页高速缓存中数据能被快速检索到,脏页面能够快速定位。
  • i_mmap - 根据 vm_area_struct,能够快速的找到关联的缓存文件(即 address_space),前面提到过, address_space 和 vm_area_struct 是 一对多的关系。
  • 其他字段主要是提供各种锁和辅助功能4 d6 f4 p/ I  O1 Y6 s

' p6 ~1 W$ L( {/ h8 I- U) s1 t
( @+ h4 P" X- z* T此外,对于这里出现的一种新的数据结构 radix 树,进行简要的说明。
& i. @& N, R- @1 f7 L2 y
. R& |# e& g3 F, b3 `radix树通过long型的位操作来查询各个节点, 存储效率高,并且可以快速查询。
- ]! F4 l; h: v& ?& _6 S( g% X7 v8 M# p( h4 O6 m# |! {/ o% y
linux中 radix树相关的内容参见: include/linux/radix-tree.h 和 lib/radix-tree.c
9 T/ p, X* ^% B0 c3 W  z
+ n; v" R! ~3 j2 \, \/ u/ T. l下面根据我自己的理解,简单的说明一下radix树结构及原理。3 i% w* @8 H5 e& i% t

" J- d! ]7 |2 m2 T
6 Y9 G+ }& D1 P9 B" J6 B" h6 d" h' T' y+ \
, I6 \+ H: \, ]2 \2.2.1 首先是 radix树节点的定义
2 h8 W6 C' ]  L- e+ Z
6 p. i9 N, \0 `6 F, m; x2 X
  • /* 源码参照 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标签 */
  • };' P, a. N; g; e: p
" Y$ O2 G" w. y: p* {
1 F4 A4 v; B- }

+ B! S" t- f) m  q弄清楚 radix_tree_node 中各个字段的含义,也就差不多知道 radix树是怎么一回事了。
% n( ^0 A7 E  x, ^1 \. t, r/ y' E  i/ Z& e! |5 b) U4 _; Z# T7 X
  • height   表示的整个 radix树的高度(即叶子节点到树根的高度), 不是当前节点到树根的高度
  • count    这个比较好理解,表示当前节点的子节点个数,叶子节点的 count=0
  • rcu_head RCU发生时触发的回调函数链表
  • slots    每个slot对应一个子节点(叶子节点)
  • tags     标记子节点是否 dirty 或者 wirteback
    ! M( r% e: q4 r( l
$ o5 I, [) q- w. x0 d; p6 H2 z: b

$ \. c/ Y7 u: E5 w2.2.2 每个叶子节点指向文件内相应偏移所对应的缓存页, Q4 w, P, {# A* d

' r! ~# s  @  N% N比如下图表示 0x000000 至 0x11111111 的偏移范围,树的高度为4 (图是网上找的,不是自己画的)
( T8 ?0 _8 ^/ ~6 |# t& S/ F; F6 v1 Y' }- N( z
  U; Q; r( C! n8 \% F' ^9 F4 u
1 [2 A( I# t/ H, E( T% A

( Q+ f" R7 `9 S6 t9 R) P$ S- O) [5 l3 r8 z3 T
2.2.3 radix tree 的叶子节点都对应一个二进制的整数,不是字符串,所以进行比较的时候非常快
" X# ^$ R- f9 z8 Q3 N  i' O7 z! b( `: U" ?. S5 S
其实叶子节点的值就是地址空间的值(一般是long型)2 m% K; F' h5 A6 m1 G

6 W# ^1 E$ A" c5 V, z; o1 y- F ) N; j. `; Q" l) F# d) [. j

1 m- ~' a. n9 u- v0 Q9 e8 i9 F3. 页回写8 r$ M" Q0 e+ s
+ j# M" x( }) V3 ~, I- Z* X
由于目前linux内核中对于「写缓存」采用的是第3种策略,所以回写的时机就显得非常重要,回写太频繁影响性能,回写太少容易造成数据丢失。
3 h0 D2 L3 X7 B5 @8 w1 o4 t( ?1 n% c, U0 }2 q! j
! e2 Q% r# R& t8 n+ D5 R
# V+ r* k: J' S$ j
3.1 简介! S+ S2 _4 q! k2 Q3 @$ D' c$ {

( l* f" ~1 @+ _, D/ g/ olinux 页高速缓存中的回写是由内核中的一个线程(flusher 线程)来完成的,flusher 线程在以下3种情况发生时,触发回写操作。
, U. y7 d$ h' N% s: V& q. v6 |
' {7 y# z2 A$ H' i( G) t1. 当空闲内存低于一个阀值时
- J' T6 _% A. x8 _; F2 I) e5 w; W9 C9 }0 `5 Q
    空闲内存不足时,需要释放一部分缓存,由于只有不脏的页面才能被释放,所以要把脏页面都回写到磁盘,使其变成干净的页面。; g+ b7 F- \2 H, s; D
+ m, E/ A4 M- x8 [
2. 当脏页在内存中驻留时间超过一个阀值时
8 q5 Y& J, T1 a, b. d- c+ |
3 R$ r2 Y! c$ [! `- d. V   确保脏页面不会无限期的驻留在内存中,从而减少了数据丢失的风险。; x  T9 ]$ H- p$ W

; {& _1 U" Z; x$ i5 T  F( M: ~, H3. 当用户进程调用 sync() 和 fsync() 系统调用时+ ?$ a8 T+ ]0 @/ L
6 b0 o$ R0 T" t; N- v8 d( C
   给用户提供一种强制回写的方法,应对回写要求严格的场景。: N2 P5 E; `5 p5 W* H7 E: U

1 K/ d1 u# K# c9 g( d % Q8 @7 c! E9 V6 g$ Z
; ?- Q/ m5 j! R
页回写中涉及的一些阀值可以在 /proc/sys/vm 中找到! a7 k$ n5 B% G- J  K% \$ x
: u3 M! D& Q- Z6 ~
下表中列出的是与 pdflush(flusher 线程的一种实现) 相关的一些阀值9 D8 v$ j% B; B" r2 j- d! _

) v) c$ ~& p( l# f0 u- ]; \
阀值
描述
dirty_background_ratio占全部内存的百分比,当内存中的空闲页达到这个比例时,pdflush线程开始回写脏页
dirty_expire_interval该数值以百分之一秒为单位,它描述超时多久的数据将被周期性执行的pdflush线程写出
dirty_ratio占全部内存的百分比,当一个进程产生的脏页达到这个比例时,就开始被写出
dirty_writeback_interval该数值以百分之一秒未单位,它描述pdflush线程的运行频率
laptop_mode一个布尔值,用于控制膝上型计算机模式

* G, b. p' r1 K- t' ^- X+ \1 N8 j: _2 m
8 d. `' \' k4 j" y' c# N0 J! Z
3.2 实现
( C3 E( t9 a1 O8 R
$ v- z9 A+ R+ `- lflusher线程的实现方法随着内核的发展也在不断的变化着。下面介绍几种在内核发展中出现的比较典型的实现方法。. N8 h2 K0 H- \

) G: N  A2 l0 g3 e( m2 V8 ]1. 膝上型计算机模式) b2 i# b! G: J$ ]# M2 u: s

+ n! E5 I% U: F0 J( U% e% u7 }这种模式的意图是将硬盘转动的机械行为最小化,允许硬盘尽可能长时间的停滞,以此延长电池供电时间。3 H' }/ Q+ Y$ o3 `0 y7 f. S3 [+ N' h: M
9 K3 {' y/ I1 \8 {/ U
该模式通过 /proc/sys/vm/laptop_mode 文件来设置。(0 - 关闭该模式  1 - 开启该模式)6 Q1 i$ U$ S- W# I0 G

) L, s3 I5 F) M* @9 m3 e9 U' |. C
! B0 U2 y1 r0 _  o/ M3 M8 b; l
3 s1 |0 n% W$ w- [2. bdflush 和 kupdated (2.6版本前 flusher 线程的实现方法), S, t2 }. a: y4 V, l- V
4 v. G6 D* {8 p& y- ?- o- Z' x
bdflush 内核线程在后台运行,系统中只有一个 bdflush 线程,当内存消耗到特定阀值以下时,bdflush 线程被唤醒
( y$ T8 I7 D& \* j1 L; H$ y
/ V3 ~6 v+ W* x6 C, Ikupdated 周期性的运行,写回脏页。
% {$ o' O. T# h4 @0 \
1 ~8 b+ }. G. T9 a3 B4 A1 w1 \ * `8 W, Y% W) d  N: |2 \$ p; v
' }2 d; N6 O( y- Z% v6 O2 r
bdflush 存在的问题:
( |6 r- t7 Q7 A% g
9 t2 V. b8 e- R- X( U整个系统仅仅只有一个 bdflush 线程,当系统回写任务较重时,bdflush 线程可能会阻塞在某个磁盘的I/O上,8 H: E8 s7 B- x0 C0 l

& @( w3 C! z8 M1 T$ z% p0 r/ m0 _  M+ T导致其他磁盘的I/O回写操作不能及时执行。. W- c4 A; }& K  w
% T$ t. V' c) j, h/ Z
$ H4 j1 s% U9 ]0 O# I

( L+ p: z- [* e! O( Q, j3. pdflush (2.6版本引入)
# e# O7 O4 v# S+ ^/ V$ S/ |1 y
, ]( H; t7 L( |8 e* w$ N' Ypdflush 线程数目是动态的,取决于系统的I/O负载。它是面向系统中所有磁盘的全局任务的。; q7 s' q; q  @2 B0 U  q
, D  ]7 V& j: ^0 f: s# m" O3 K

  a) S2 t8 j; D) c5 _
, ~4 Y/ K4 d& b' D  F* Rpdflush 存在的问题:3 j" ^& [0 p1 c  t( s( ]' O% v6 o
( R" L* h: i: H
pdflush的数目是动态的,一定程度上缓解了 bdflush 的问题。但是由于 pdflush 是面向所有磁盘的,' T* Z* W& e+ ]* N# h, V

6 z7 n) E% j6 m) j9 k% v! F1 L所以有可能出现多个 pdflush 线程全部阻塞在某个拥塞的磁盘上,同样导致其他磁盘的I/O回写不能及时执行。- L4 ~* W& h; \- R" ^0 e+ `
3 U6 e  X3 g. E% e& S( A7 }
# j# z& Z- `; f2 K

4 U9 Z+ C5 K8 r: {6 }! `: k6 m4. flusher线程 (2.6.32版本后引入)
3 n2 z2 m7 M/ p2 C
4 n/ d9 M& V( u, Mflusher线程改善了上面出现的问题:1 c! f; ]1 z; ?' I, Z# e; j2 I

8 P6 B+ ?' ?4 l, d! ]6 y首先,flusher 线程的数目不是唯一的,这就避免了 bdflush 线程的问题
1 V) Y7 [1 l% P; ~# `9 ?8 e5 G3 l: a4 [$ A& T: |
其次,flusher 线程不是面向所有磁盘的,而是每个 flusher 线程对应一个磁盘,这就避免了 pdflush 线程的问题
* n7 y5 h# u- _$ x* p

该用户从未签到

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

本版积分规则

关闭

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

EDA365公众号

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

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

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

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

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