From patchwork Fri Sep 20 06:35:07 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Hui Zhu X-Patchwork-Id: 11153811 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 68A2176 for ; Fri, 20 Sep 2019 06:35:24 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 31AFA208C3 for ; Fri, 20 Sep 2019 06:35:24 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 31AFA208C3 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.alibaba.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 761906B04B5; Fri, 20 Sep 2019 02:35:23 -0400 (EDT) Delivered-To: linux-mm-outgoing@kvack.org Received: by kanga.kvack.org (Postfix, from userid 40) id 738526B04B6; Fri, 20 Sep 2019 02:35:23 -0400 (EDT) X-Original-To: int-list-linux-mm@kvack.org X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 64E876B04B7; Fri, 20 Sep 2019 02:35:23 -0400 (EDT) X-Original-To: linux-mm@kvack.org X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0112.hostedemail.com [216.40.44.112]) by kanga.kvack.org (Postfix) with ESMTP id 442AC6B04B5 for ; Fri, 20 Sep 2019 02:35:23 -0400 (EDT) Received: from smtpin17.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay04.hostedemail.com (Postfix) with SMTP id D99DE1F84E for ; Fri, 20 Sep 2019 06:35:22 +0000 (UTC) X-FDA: 75954337284.17.guide13_2ed054e433d0b X-Spam-Summary: 50,0,0,7b569d7bee3d19c0,d41d8cd98f00b204,teawaterz@linux.alibaba.com,:sjenning@redhat.com:ddstreet@ieee.org:akpm@linux-foundation.org:mhocko@suse.com:willy@infradead.org:chris@chris-wilson.co.uk:hannes@cmpxchg.org:ziqian.lzq@antfin.com:osandov@fb.com:ying.huang@intel.com:aryabinin@virtuozzo.com:vovoy@chromium.org:richard.weiyang@gmail.com:jgg@ziepe.ca:dan.j.williams@intel.com:rppt@linux.ibm.com:jglisse@redhat.com:b.zolnierkie@samsung.com:axboe@kernel.dk:dennis@kernel.org:josef@toxicpanda.com:tj@kernel.org:oleg@redhat.com:linux-kernel@vger.kernel.org::teawaterz@linux.alibaba.com,RULES_HIT:2:41:355:379:541:960:967:973:988:989:1260:1261:1345:1437:1535:1605:1730:1747:1777:1792:2393:2525:2560:2563:2682:2685:2693:2859:2895:2933:2937:2939:2942:2945:2947:2951:2954:3022:3138:3139:3140:3141:3142:3865:3866:3867:3868:3870:3871:3872:3874:3934:3936:3938:3941:3944:3947:3950:3953:3956:3959:4049:4119:4250:4321:4605:5007:6119:6120:6261:6737:6738:7903:8985:9025:10004:11026:11473 :11658:1 X-HE-Tag: guide13_2ed054e433d0b X-Filterd-Recvd-Size: 8188 Received: from out30-56.freemail.mail.aliyun.com (out30-56.freemail.mail.aliyun.com [115.124.30.56]) by imf12.hostedemail.com (Postfix) with ESMTP for ; Fri, 20 Sep 2019 06:35:21 +0000 (UTC) X-Alimail-AntiSpam: AC=PASS;BC=-1|-1;BR=01201311R191e4;CH=green;DM=||false|;FP=0|-1|-1|-1|0|-1|-1|-1;HT=e01f04446;MF=teawaterz@linux.alibaba.com;NM=1;PH=DS;RN=26;SR=0;TI=SMTPD_---0TcrUSCY_1568961310; Received: from localhost(mailfrom:teawaterz@linux.alibaba.com fp:SMTPD_---0TcrUSCY_1568961310) by smtp.aliyun-inc.com(127.0.0.1); Fri, 20 Sep 2019 14:35:14 +0800 From: Hui Zhu To: sjenning@redhat.com, ddstreet@ieee.org, akpm@linux-foundation.org, mhocko@suse.com, willy@infradead.org, chris@chris-wilson.co.uk, hannes@cmpxchg.org, ziqian.lzq@antfin.com, osandov@fb.com, ying.huang@intel.com, aryabinin@virtuozzo.com, vovoy@chromium.org, richard.weiyang@gmail.com, jgg@ziepe.ca, dan.j.williams@intel.com, rppt@linux.ibm.com, jglisse@redhat.com, b.zolnierkie@samsung.com, axboe@kernel.dk, dennis@kernel.org, josef@toxicpanda.com, tj@kernel.org, oleg@redhat.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Cc: Hui Zhu Subject: [RFC v2] zswap: Add CONFIG_ZSWAP_IO_SWITCH to handle swap IO issue Date: Fri, 20 Sep 2019 14:35:07 +0800 Message-Id: <1568961307-32419-1-git-send-email-teawaterz@linux.alibaba.com> X-Mailer: git-send-email 2.7.4 X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: This is the second version of this patch. The previous version is in https://lkml.org/lkml/2019/9/11/935 I updated the commit introduction and Kconfig because it is not clear. Currently, I use a VM that has 2 CPUs, 4G memory and 4G swap file. I found that swap will affect the IO performance when it is running. So I open zswap to handle it because it just use CPU cycles but not disk IO. It work OK but I found that zswap is slower than normal swap in this VM. zswap is about 300M/s and normal swap is about 500M/s. (The reason is disk inside VM has fscache in host machine.) So open zswap is make memory shrinker slower but good for IO performance in this VM. So I just want zswap work when the disk of the swap file is under high IO load. This commit is designed for this idea. It add two parameters read_in_flight_limit and write_in_flight_limit to zswap. In zswap_frontswap_store, pages will be stored to zswap only when the IO in flight number of swap device is bigger than zswap_read_in_flight_limit or zswap_write_in_flight_limit when zswap is enabled. Then the zswap just work when the IO in flight number of swap device is low. Signed-off-by: Hui Zhu --- include/linux/swap.h | 3 +++ mm/Kconfig | 18 +++++++++++++++++ mm/page_io.c | 16 +++++++++++++++ mm/zswap.c | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 92 insertions(+) diff --git a/include/linux/swap.h b/include/linux/swap.h index de2c67a..82b621f 100644 --- a/include/linux/swap.h +++ b/include/linux/swap.h @@ -389,6 +389,9 @@ extern void end_swap_bio_write(struct bio *bio); extern int __swap_writepage(struct page *page, struct writeback_control *wbc, bio_end_io_t end_write_func); extern int swap_set_page_dirty(struct page *page); +#ifdef CONFIG_ZSWAP_IO_SWITCH +extern void swap_io_in_flight(struct page *page, unsigned int inflight[2]); +#endif int add_swap_extent(struct swap_info_struct *sis, unsigned long start_page, unsigned long nr_pages, sector_t start_block); diff --git a/mm/Kconfig b/mm/Kconfig index 56cec63..5408d65 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -546,6 +546,24 @@ config ZSWAP they have not be fully explored on the large set of potential configurations and workloads that exist. +config ZSWAP_IO_SWITCH + bool "Compressed cache for swap pages according to the IO status" + depends on ZSWAP + def_bool n + help + This function help the system that normal swap speed is higher + than zswap speed to handle the swap IO issue. + For example, a VM that is disk device is not set cache config or + set cache=writeback. + + This function make zswap just work when the disk of the swap file + is under high IO load. + It add two parameters read_in_flight_limit and write_in_flight_limit to + zswap. When zswap is enabled, pages will be stored to zswap only + when the IO in flight number of swap device is bigger than + zswap_read_in_flight_limit or zswap_write_in_flight_limit. + If unsure, say "n". + config ZPOOL tristate "Common API for compressed memory storage" help diff --git a/mm/page_io.c b/mm/page_io.c index 24ee600..e66b050 100644 --- a/mm/page_io.c +++ b/mm/page_io.c @@ -434,3 +434,19 @@ int swap_set_page_dirty(struct page *page) return __set_page_dirty_no_writeback(page); } } + +#ifdef CONFIG_ZSWAP_IO_SWITCH +void swap_io_in_flight(struct page *page, unsigned int inflight[2]) +{ + struct swap_info_struct *sis = page_swap_info(page); + + if (!sis->bdev) { + inflight[0] = 0; + inflight[1] = 0; + return; + } + + part_in_flight_rw(bdev_get_queue(sis->bdev), sis->bdev->bd_part, + inflight); +} +#endif diff --git a/mm/zswap.c b/mm/zswap.c index 0e22744..1255645 100644 --- a/mm/zswap.c +++ b/mm/zswap.c @@ -62,6 +62,13 @@ static u64 zswap_reject_compress_poor; static u64 zswap_reject_alloc_fail; /* Store failed because the entry metadata could not be allocated (rare) */ static u64 zswap_reject_kmemcache_fail; +#ifdef CONFIG_ZSWAP_IO_SWITCH +/* Store failed because zswap_read_in_flight_limit or + * zswap_write_in_flight_limit is bigger than IO in flight number of + * swap device + */ +static u64 zswap_reject_io; +#endif /* Duplicate store was encountered (rare) */ static u64 zswap_duplicate_entry; @@ -114,6 +121,22 @@ static bool zswap_same_filled_pages_enabled = true; module_param_named(same_filled_pages_enabled, zswap_same_filled_pages_enabled, bool, 0644); +#ifdef CONFIG_ZSWAP_IO_SWITCH +/* zswap will not try to store the page if zswap_read_in_flight_limit is + * bigger than IO read in flight number of swap device + */ +static unsigned int zswap_read_in_flight_limit; +module_param_named(read_in_flight_limit, zswap_read_in_flight_limit, + uint, 0644); + +/* zswap will not try to store the page if zswap_write_in_flight_limit is + * bigger than IO write in flight number of swap device + */ +static unsigned int zswap_write_in_flight_limit; +module_param_named(write_in_flight_limit, zswap_write_in_flight_limit, + uint, 0644); +#endif + /********************************* * data structures **********************************/ @@ -1009,6 +1032,34 @@ static int zswap_frontswap_store(unsigned type, pgoff_t offset, goto reject; } +#ifdef CONFIG_ZSWAP_IO_SWITCH + if (zswap_read_in_flight_limit || zswap_write_in_flight_limit) { + unsigned int inflight[2]; + bool should_swap = false; + + swap_io_in_flight(page, inflight); + + if (zswap_write_in_flight_limit && + inflight[1] < zswap_write_in_flight_limit) + should_swap = true; + + if (zswap_read_in_flight_limit && + (should_swap || + (!should_swap && !zswap_write_in_flight_limit))) { + if (inflight[0] < zswap_read_in_flight_limit) + should_swap = true; + else + should_swap = false; + } + + if (should_swap) { + zswap_reject_io++; + ret = -EIO; + goto reject; + } + } +#endif + /* reclaim space if needed */ if (zswap_is_full()) { zswap_pool_limit_hit++; @@ -1264,6 +1315,10 @@ static int __init zswap_debugfs_init(void) zswap_debugfs_root, &zswap_reject_kmemcache_fail); debugfs_create_u64("reject_compress_poor", 0444, zswap_debugfs_root, &zswap_reject_compress_poor); +#ifdef CONFIG_ZSWAP_IO_SWITCH + debugfs_create_u64("reject_io", 0444, + zswap_debugfs_root, &zswap_reject_io); +#endif debugfs_create_u64("written_back_pages", 0444, zswap_debugfs_root, &zswap_written_back_pages); debugfs_create_u64("duplicate_entry", 0444,