F2FS源码分析-4.2 [F2FS GC部分] Victim Segment的选择策略

最新推荐文章于 2023-01-11 17:51:53 发布
最新推荐文章于 2023-01-11 17:51:53 发布
阅读量1.2k 收藏 3
点赞数 4
分类专栏： 页缓存及文件系统 # F2FS架构以及源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011649400/article/details/100530021
版权
F2FS源码分析系列文章
主目录
一、文件系统布局以及元数据结构
二、文件数据的存储以及读写
三、文件与目录的创建以及删除(未完成)
四、垃圾回收机制
  1. 垃圾回收流程分析
  2. Victim Segment的选择策略
五、数据恢复机制
六、重要数据结构或者函数的分析

victim segment的选择

在垃圾回收流程分析这一节提及到了gc会通过__get_victim函数去选择一个需要被gc的segment。怎么样的segment才适合被gc，而F2FS是如何实现这一个流程的呢? 本节对这部分源码进行分析。

我们首先分析__get_victim函数，如下所示:

static int __get_victim(struct f2fs_sb_info *sbi, unsigned int *victim,
			int gc_type)
{
	struct sit_info *sit_i = SIT_I(sbi);
	int ret;

	mutex_lock(&sit_i->sentry_lock);
	ret = DIRTY_I(sbi)->v_ops->get_victim(sbi, victim, gc_type,
					      NO_CHECK_TYPE, LFS);
	mutex_unlock(&sit_i->sentry_lock);
	return ret;
}

这里f2fs通过接口的方式提供给用户一个实现自己的垃圾回收算法能力。在默认情况下f2fs通过get_victim_by_default实现victim segment的选择:

static const struct victim_selection default_v_ops = {
	.get_victim = get_victim_by_default,
};

我们先浏览一个简化的get_victim_by_default函数的结构，再逐步分析:

static int get_victim_by_default(struct f2fs_sb_info *sbi,
		unsigned int *result, int gc_type, int type, char alloc_mode)
{
	struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
	struct victim_sel_policy p;
	unsigned int secno, max_cost;
	int nsearched = 0;

	/* 初始化选择策略 */
	p.alloc_mode = alloc_mode;
	select_policy(sbi, gc_type, type, &p);

	p.min_segno = NULL_SEGNO;
	p.min_cost = max_cost = get_max_cost(sbi, &p);

	/* 前台gc模式要求快速释放空间，因此不做循环寻找，直接找到之前BG GC的时候所记录下来适合gc的的segment进行gc */
	if (p.alloc_mode == LFS && gc_type == FG_GC) {
		p.min_segno = check_bg_victims(sbi);
		if (p.min_segno != NULL_SEGNO)
			goto got_it;
	}

	/* 进入循环，找到一个最小cost的segment */
	while (1) {
		unsigned long cost;
		unsigned int segno;

		/* 从map里面找到一个dirty的segment所以对应segno出来 */
		segno = find_next_bit(p.dirty_segmap, MAIN_SEGS(sbi), p.offset);

		p.offset = segno + p.ofs_unit;
		if (p.ofs_unit > 1)
			p.offset -= segno % p.ofs_unit;

		secno = GET_SECNO(sbi, segno);
			
		/* 计算当前segment的cost */
		cost = get_gc_cost(sbi, segno, &p);

		/* 判断更新最小cost */
		if (p.min_cost > cost) {
			p.min_segno = segno;
			p.min_cost = cost;
		} else if (unlikely(cost == max_cost)) {
			continue;
		}

		/* 达到了最大搜索次数即退出 */
		if (nsearched++ >= p.max_search) {
			sbi->last_victim[p.gc_mode] = segno;
			break;
		}
	}
	if (p.min_segno != NULL_SEGNO) {
got_it:
		if (p.alloc_mode == LFS) {
			secno = GET_SECNO(sbi, p.min_segno);
			if (gc_type == FG_GC)
				sbi->cur_victim_sec = secno;
			else
				set_bit(secno, dirty_i->victim_secmap); // BG_GC的情况下设定这个map，给FG_GC快速寻找segment进行gc
		}
		*result = (p.min_segno / p.ofs_unit) * p.ofs_unit; // 返回结果
	}

	return (p.min_segno == NULL_SEGNO) ? 0 : 1;
}

设置victim segment选择策略

第一步设置victim_sel_policy，即victim segment选择策略:

struct victim_sel_policy p;
p.alloc_mode = alloc_mode; // 设置分配模式，一般为LFS
select_policy(sbi, gc_type, type, &p); // 根据gc类型等信息，设定选择策略
p.min_segno = NULL_SEGNO;
p.min_cost = max_cost = get_max_cost(sbi, &p); // 根据不同的policy，设定最大回收cost

其中

static void select_policy(struct f2fs_sb_info *sbi, int gc_type,
			int type, struct victim_sel_policy *p)
{
	struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);

	if (p->alloc_mode == SSR) {
		p->gc_mode = GC_GREEDY;
		p->dirty_segmap = dirty_i->dirty_segmap[type];
		p->max_search = dirty_i->nr_dirty[type];
		p->ofs_unit = 1;
	} else {
		p->gc_mode = select_gc_type(sbi->gc_thread, gc_type); // 赋予gc算法类型，默认有两种算法，即greedy算法(GC_GREEDY)，以及cost-benefit算法(GC_CB)
		p->dirty_segmap = dirty_i->dirty_segmap[DIRTY]; // 即脏的segment所对应的segmap，它的作用是标记了这个segmen里面的block有效无效信息
		p->max_search = dirty_i->nr_dirty[DIRTY]; // 表示最大搜索次数，等于当前有多少个dirty的segment
		p->ofs_unit = sbi->segs_per_sec; // 1 sec = 1 seg ，所以等于1
	}

	if (p->max_search > sbi->max_victim_search)
		p->max_search = sbi->max_victim_search;

	p->offset = sbi->last_victim[p->gc_mode]; // 上一个被回收的segment
}

查找最小cost的segment

在分析下一步循环之前，我们要明确循环的目的是什么。f2fs通过变量cost表示gc这个segment所带来的开销，cost的值根据不同的算法也不一样。get_victim_by_default函数目的是找到一个cost最低的segment进行回收，因此在找到之前需要设定一个最大cost，用于一步步遍历降低cost。

	while (1) {
		unsigned long cost;
		unsigned int segno;

		/* 从map里面找到一个dirty的segment所以对应segno出来 */
		segno = find_next_bit(p.dirty_segmap, MAIN_SEGS(sbi), p.offset);

		p.offset = segno + p.ofs_unit;
		if (p.ofs_unit > 1)
			p.offset -= segno % p.ofs_unit;

		secno = GET_SECNO(sbi, segno);
			
		/* 计算当前segment的cost */
		cost = get_gc_cost(sbi, segno, &p);

		/* 判断更新最小cost */
		if (p.min_cost > cost) {
			p.min_segno = segno;
			p.min_cost = cost;
		} else if (unlikely(cost == max_cost)) {
			continue;
		}

		/* 达到了最大搜索次数即退出 */
		if (nsearched++ >= p.max_search) {
			sbi->last_victim[p.gc_mode] = segno;
			break;
		}
	}

首先通过find_next_bit 函数，从p.dirty_segmap找到第一个dirty的segment出来，然后通过get_gc_cost函数计算这个segment的cost。然后判断是否少于p.min_cost，然后赋值。最后循环到达了最大搜索次数以后旧退出。此时的segment及时本次选择过程中得到的cost最小的segment，最后返回到*result中，完成这个victim segment选择流程。

cost算法

F2FS使用了两种计算cost的算法，分别是Greedy算法和Cost-Benefit算法。

static inline unsigned int get_gc_cost(struct f2fs_sb_info *sbi,
			unsigned int segno, struct victim_sel_policy *p)
{
	if (p->alloc_mode == SSR)
		return get_seg_entry(sbi, segno)->ckpt_valid_blocks;

	/* alloc_mode == LFS */
	if (p->gc_mode == GC_GREEDY)
		return get_valid_blocks(sbi, segno, sbi->segs_per_sec); // Greedy算法，valid block越多表示cost越大，越不值得gc
	else
		return get_cb_cost(sbi, segno); // Cost-Benefit算法，这个是考虑了访问时间和valid block开销的算法
}

由于是通过cost值表示是否值得被gc，因此cost值是越小越好。

Greedy算法
顾名思义，会选择invalid block最多(valid block最少)的segment进行gc，实现如下:

static inline unsigned int get_valid_blocks(struct f2fs_sb_info *sbi,
				unsigned int segno, int section)
{
	if (section > 1)
		return get_sec_entry(sbi, segno)->valid_blocks;
	else
		return get_seg_entry(sbi, segno)->valid_blocks;
}

由于是通过cost来描述开销，因此这里valid_block越多，表示开销越大。

Cost-Benefit算法
Cost-Benefit算法是一个同时考虑最近一次修改时间以及invalid block个数的算法。因为相当于频繁修改的数据而言，不值得进行GC，因为GC完很快就修改了，同时由于异地更新的特性，导致继续产生invalid block。较长时间未作修改的数据，可以认为迁移以后也相对没那么频繁继续产生invalid block。Cost-Benefit算法的核心是:

cost = (1 - u) / 2u * age
其中
u: 表示valid block在该section中的比例，age代表该section最近一次修改的时间
1-u: 表示对这个section进行gc后的收益
2u: 则表示开销(读+写)
age: 表示上一次修改时间

因此我们可以将Cost-Benefit算法理解为一个平衡invalid block数目以及修改时间的的一个算法，在f2fs的实现如下:

static unsigned int get_cb_cost(struct f2fs_sb_info *sbi, unsigned int segno)
{
	struct sit_info *sit_i = SIT_I(sbi);
	unsigned int secno = GET_SECNO(sbi, segno);
	unsigned int start = secno * sbi->segs_per_sec;
	unsigned long long mtime = 0;
	unsigned int vblocks;
	unsigned char age = 0;
	unsigned char u;
	unsigned int i;

	for (i = 0; i < sbi->segs_per_sec; i++)
		mtime += get_seg_entry(sbi, start + i)->mtime; // 计算section里面的每一个segment最近一次访问时间
	vblocks = get_valid_blocks(sbi, segno, sbi->segs_per_sec); // 获取当前的section有多少个valid block

	mtime = div_u64(mtime, sbi->segs_per_sec); // 计算平均每一segment的最近一次访问时间
	vblocks = div_u64(vblocks, sbi->segs_per_sec); // 计算平均每一个segment的valid block个数

	u = (vblocks * 100) >> sbi->log_blocks_per_seg; // 百分比计算所以乘以100，然后计算得到了valid block的比例

	/* sit_i->min_mtime以及sit_i->max_mtime计算的是每一次gc的时候的最小最大的修改时间，因此通过这个比例计算这个section的修改时间在总体的情况下的表现 */
	if (mtime < sit_i->min_mtime)
		sit_i->min_mtime = mtime;
	if (mtime > sit_i->max_mtime)
		sit_i->max_mtime = mtime;
	if (sit_i->max_mtime != sit_i->min_mtime)
		age = 100 - div64_u64(100 * (mtime - sit_i->min_mtime),
				sit_i->max_mtime - sit_i->min_mtime);

	return UINT_MAX - ((100 * (100 - u) * age) / (100 + u));
}

第一步先计算一个section平均每一个segment的valid block数目是多少，然后计算valid block的比例。
第二步计算上一次修改时间占据最大最小的修改时间的比例。
最后一步，公式((100 * (100 - u) * age) / (100 + u))即对应(1 - u) / 2u * age，使用UINT_MAX减去这个值的原因是f2fs要维持cost越高，越不值得被gc的特征。

HuberyPan
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
f2fs系列文章gc
WaterWin的博客
11-26 2408
    这篇文章将讲述f2fs的gc，其主要的步骤应该是分为两步，首先select一个合适的section，然后将section中的数据全部迁移。       f2fs_gc：这个函数主要有两个函数调用gc线程和f2fs_balance_fs。首先检查super_block是否设置MS_ACTIVE,也就是super_block处于活动状态（目前不知道什么个状态），如果设置了就不做gc了。然后...
f2fs——FG_GC优化之从GREEDY算法修改为CAT算法源码
08-01
f2fs——FG_GC优化之从GREEDY算法修改为CAT算法源码
F2FS的GC策略
qq_36059308的博客
01-04 1585
F2FS的GC策略 F2FS 主要以两种方式执行GC操作，即 foreground gc 和 background gc。当空闲section不足时，F2FS会触发 foreground gc，而内核会周期性唤醒 background gc 进程，在系统空闲时回收空间。 文献【1】指出，F2FS 的 background gc 也不是随时随地都能触发成功的，background gc 被唤醒后会检查系统的状态是否符合条件，并仅在以下三种情况会成功触发 background gc： 设备连着充电线，用户没有
f2fs GC 解密
weixin_34341117的博客
05-29 563
名词解释 cleaning 是append文件系统中常用术语，和trim有联系，但也需要注意他们之间的区别和联系： cleaning: LFS 删去无效数据的过程trim: SSD 内部删把dirty块设置成invalid，以备后续使用的过程 背景 鉴于之前评测的nvme SSD场景下 f2fs 整体性能表现出色，有必要分析其背后的根本原因。f2fs作为一种append模式的文件系统，cleani...
[F2FS GC部分] Victim Segment的选择策略
qq_38232437的博客
09-28 276
victim segment的选择 在垃圾回收流程分析这一节提及到了gc会通过__get_victim函数去选择一个需要被gc的segment。怎么样的segment才适合被gc，而F2FS是如何实现这一个流程的呢? 本节对这部分源码进行分析。 我们首先分析__get_victim函数，如下所示: static int __get_victim(struct f2fs_sb_info *sbi, unsigned int *victim, int gc_type) { struct sit_info
F2FS源码分析-4.1 [F2FS GC部分] 垃圾回收机制源码分析
Hubery的存储点滴
09-03 4156
F2FS的GC流程 垃圾回收(Garbage Collection)在F2FS中，主要作用是回收无效的block，以供用户重新使用。在详细介绍GC之前，需要先分析一下为什么需要GC。 Append-Only Logging文件系统的特征 F2FS是一个基于Append-Only Logging的文件系统，而垃圾回收则是Append-Only Logging文件系统一个非常重要的特征，因为其独特的数...
bsidesto-victim:bsides-to talk 的受害者代码
07-12
与我的 bsidesTO talk 一起使用的代码示例
Webshel​​l-Sniper：通过终端管理您的网站
03-03
Webshel​​l狙击手通过终端的webshel​​l管理器用法 ： Usage : python webshell-sniper.py [URL] ...# python webshell-sniper.py http://victim.com/index.php POST s3cr3t...安装： git clone https://github.com
pt-kill 常用杀进程参数介绍
09-10
使用 `--match-command` 和 `--ignore-command` 参数，你可以根据 MySQL 进程的状态来选择要杀掉的进程。例如，`--match-command="query | Execute"` 将杀死所有执行查询或执行操作的进程。命令的名称必须完全匹配...
GTA-SA:欢迎来到圣安地列斯！
05-07
在表带上，那就是OG保持体形，锻炼身体，举起重物超级剪裁或大而浅的buff，漂亮而笔直的你拥有统计数据，尊重，武器技能耐力，肌肉，脂肪和性吸引力从Bincos购买衣服和Pro Laps Sub Urban，ZIP，Victim和D....
死锁算法的实验执行-研究论文
05-19
当一组进程请求当前正被... 在本文中，我们提供了死锁方案的实际实现以及死锁概念，包括互斥，保留和等待，无抢占，循环等待，进程终止，选择受害者，回滚和饥饿。 Java编程语言用于开发我们在本文中介绍的所有算法。
f2fs学习笔记 -11. f2fs gc
HZero
01-11 718
1.前言 GC分为前台GC和后台GC 2.总体流程 f2fs_fill_super start_gc_thread(sbi) init_waitqueue_head(&sbi->gc_thread->gc_wait_queue_head) kthread_run（gc_thread_func） 3.gc_thread_func gc_thread_func f2fs_balance_fs(sbi) sync_dirty_dir_inodes sync_node_pa
f2fs——新型flash友好文件系统gc部分源码分析
AO的博客
07-25 5537
1、F2FS数据布局   F2FS 将整个卷切分成大量的 Segments，每个 Segment 的大小是固定的2 MB。连续的若干个Segments 构成 Section，连续的若干个 Sections 构成 Zone。 F2FS 将整个卷切分成6个区域，除了超级块(Superblock，SB)外，其余每个区域都包含多个 Segments。 F2FS数据布局参考博客：http://blo
f2fs gc garbage collect 过程分析
tianweishuiguo的专栏
10-13 1270
f2fs mount时，会启动garbage collect线程，garbage collect线程通过wait_event_interruptible_timeout函数，每隔一段时间，或者等待的condition为true时，判断是否需要执行garbage collect操作。 static int gc_thread_func(void *data) { struct f2fs_sb...
f2fs——FG_GC优化之从GREEDY算法修改为CAT算法并测试
AO的博客
08-01 1887
f2fs模块单独编译命令：make CONFIG_F2FS_FS=m -C /root/linux-3.14 M=/root/linux-3.14/fs/f2fs modules   原来编译kernel时直接将f2fs文件系统buildin了，重新将f2fs选择为module，再编译kernel。   sec_usage_check: section的使用时间检查，若是当前sectio
f2fs学习笔记 - 1. f2fs概述
HZero
01-10 6698
1. 前言 本文主要通过回答几个问题来概要了解f2fs，这几个问题包括： f2fs是什么？ 为何引入f2fs? f2fs如何工作？ f2fs如何做到随机写入顺序化？ f2fs如何解决雪崩问题？ 2. f2fs是什么？ F2FS (Flash Friendly File System) 是专门针对SSD、eMMC、UFS等闪存设备设计的文件系统。基于LFS，同时解决了LFS的一些问题。由三星工程师Jaegeuk Kim于2012年10月发布到Linux社区，并于2012年12月进入Linux 3.8 内核
【开源】F2FS技术拆解
Dayu_log的博客
01-11 1484
开源 FS
学习F2FS过程中笔记一
wanlanjian的专栏
04-01 1331
解决问题1：F2FS的目录结构理解 F2FS使用到文件哈希是分层的。 每个block有214个目录槽。一个目录槽最多存1个文件夹信息。 第一层就一个哈希桶，一个哈希桶有2个blocks，每个block有214个目录槽。每个目录槽最大存一个目录信息。 第二层有1&lt;&lt;1(即2)个哈希桶，每个哈希桶2个blocks 第三层有1&lt;&lt;2(即4)个哈希桶，每个哈希桶2个blo...
filesystem - 挂载f2fs
zw423795258的专栏
07-05 2958
Documentation/filesystems/f2fs.txt ======================================================= 使用 ======================================================= 1、下载用户层的工具，编译 2、如果在内核编译的时候编译了f2fs模块，跳
使用LRU策略删除一个victim frame，这个函数能得到frame_id
最新发布
05-11
LRU策略是一种最近最少使用算法，它会选择最久未使用的页面进行置换。在实现LRU策略删除一个victim frame时，需要记录每个页面最近一次被访问的时间戳，并按照时间戳排序。当需要删除页面时，选择时间戳最小的页面...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值