mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-19 10:14:23 +08:00
a26b7c8a01
This patch improves the gc efficiency by optimizing the victim selection policy. With this optimization, the random re-write performance could increase up to 20%. For f2fs, when disk is in shortage of free spaces, gc will selects dirty segments and moves valid blocks around for making more space available. The gc cost of a segment is determined by the valid blocks in the segment. The less the valid blocks, the higher the efficiency. The ideal victim segment is the one that has the most garbage blocks. Currently, it searches up to 20 dirty segments for a victim segment. The selected victim is not likely the best victim for gc when there are much more dirty segments. Why not searching more dirty segments for a better victim? The cost of searching dirty segments is negligible in comparison to moving blocks. In this patch, it enlarges the MAX_VICTIM_SEARCH to 4096 to make the search more aggressively for a possible better victim. Since it also applies to victim selection for SSR, it will likely improve the SSR efficiency as well. The test case is simple. It creates as many files until the disk full. The size for each file is 32KB. Then it writes as many as 100000 records of 4KB size to random offsets of random files in sync mode. The testing was done on a 2GB partition of a SDHC card. Let's see the test result of f2fs without and with the patch. --------------------------------------- 2GB partition, SDHC create 52023 files of size 32768 bytes random re-write 100000 records of 4KB --------------------------------------- | file creation (s) | rewrite time (s) | gc count | gc garbage blocks | [no patch] 341 4227 1174 174840 [patched] 324 2958 645 106682 It's obvious that, with the patch, f2fs finishes the test in 20+% less time than without the patch. And internally it does much less gc with higher efficiency than before. Since the performance improvement is related to gc, it might not be so obvious for other tests that do not trigger gc as often as this one ( This is because f2fs selects dirty segments for SSR use most of the time when free space is in shortage). The well-known iozone test tool was not used for benchmarking the patch becuase it seems do not have a test case that performs random re-write on a full disk. This patch is the revised version based on the suggestion from Jaegeuk Kim. Signed-off-by: Jin Xu <jinuxstyle@gmail.com> [Jaegeuk Kim: suggested simpler solution] Reviewed-by: Jaegeuk Kim <jaegeuk.kim@samsung.com> Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
111 lines
3.0 KiB
C
111 lines
3.0 KiB
C
/*
|
|
* fs/f2fs/gc.h
|
|
*
|
|
* Copyright (c) 2012 Samsung Electronics Co., Ltd.
|
|
* http://www.samsung.com/
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
#define GC_THREAD_MIN_WB_PAGES 1 /*
|
|
* a threshold to determine
|
|
* whether IO subsystem is idle
|
|
* or not
|
|
*/
|
|
#define DEF_GC_THREAD_MIN_SLEEP_TIME 30000 /* milliseconds */
|
|
#define DEF_GC_THREAD_MAX_SLEEP_TIME 60000
|
|
#define DEF_GC_THREAD_NOGC_SLEEP_TIME 300000 /* wait 5 min */
|
|
#define LIMIT_INVALID_BLOCK 40 /* percentage over total user space */
|
|
#define LIMIT_FREE_BLOCK 40 /* percentage over invalid + free space */
|
|
|
|
/* Search max. number of dirty segments to select a victim segment */
|
|
#define MAX_VICTIM_SEARCH 4096 /* covers 8GB */
|
|
|
|
struct f2fs_gc_kthread {
|
|
struct task_struct *f2fs_gc_task;
|
|
wait_queue_head_t gc_wait_queue_head;
|
|
|
|
/* for gc sleep time */
|
|
unsigned int min_sleep_time;
|
|
unsigned int max_sleep_time;
|
|
unsigned int no_gc_sleep_time;
|
|
|
|
/* for changing gc mode */
|
|
unsigned int gc_idle;
|
|
};
|
|
|
|
struct inode_entry {
|
|
struct list_head list;
|
|
struct inode *inode;
|
|
};
|
|
|
|
/*
|
|
* inline functions
|
|
*/
|
|
static inline block_t free_user_blocks(struct f2fs_sb_info *sbi)
|
|
{
|
|
if (free_segments(sbi) < overprovision_segments(sbi))
|
|
return 0;
|
|
else
|
|
return (free_segments(sbi) - overprovision_segments(sbi))
|
|
<< sbi->log_blocks_per_seg;
|
|
}
|
|
|
|
static inline block_t limit_invalid_user_blocks(struct f2fs_sb_info *sbi)
|
|
{
|
|
return (long)(sbi->user_block_count * LIMIT_INVALID_BLOCK) / 100;
|
|
}
|
|
|
|
static inline block_t limit_free_user_blocks(struct f2fs_sb_info *sbi)
|
|
{
|
|
block_t reclaimable_user_blocks = sbi->user_block_count -
|
|
written_block_count(sbi);
|
|
return (long)(reclaimable_user_blocks * LIMIT_FREE_BLOCK) / 100;
|
|
}
|
|
|
|
static inline long increase_sleep_time(struct f2fs_gc_kthread *gc_th, long wait)
|
|
{
|
|
if (wait == gc_th->no_gc_sleep_time)
|
|
return wait;
|
|
|
|
wait += gc_th->min_sleep_time;
|
|
if (wait > gc_th->max_sleep_time)
|
|
wait = gc_th->max_sleep_time;
|
|
return wait;
|
|
}
|
|
|
|
static inline long decrease_sleep_time(struct f2fs_gc_kthread *gc_th, long wait)
|
|
{
|
|
if (wait == gc_th->no_gc_sleep_time)
|
|
wait = gc_th->max_sleep_time;
|
|
|
|
wait -= gc_th->min_sleep_time;
|
|
if (wait <= gc_th->min_sleep_time)
|
|
wait = gc_th->min_sleep_time;
|
|
return wait;
|
|
}
|
|
|
|
static inline bool has_enough_invalid_blocks(struct f2fs_sb_info *sbi)
|
|
{
|
|
block_t invalid_user_blocks = sbi->user_block_count -
|
|
written_block_count(sbi);
|
|
/*
|
|
* Background GC is triggered with the following condition.
|
|
* 1. There are a number of invalid blocks.
|
|
* 2. There is not enough free space.
|
|
*/
|
|
if (invalid_user_blocks > limit_invalid_user_blocks(sbi) &&
|
|
free_user_blocks(sbi) < limit_free_user_blocks(sbi))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
static inline int is_idle(struct f2fs_sb_info *sbi)
|
|
{
|
|
struct block_device *bdev = sbi->sb->s_bdev;
|
|
struct request_queue *q = bdev_get_queue(bdev);
|
|
struct request_list *rl = &q->root_rl;
|
|
return !(rl->count[BLK_RW_SYNC]) && !(rl->count[BLK_RW_ASYNC]);
|
|
}
|