2012-01-09 22:51:56 +00:00
|
|
|
/*
|
|
|
|
* zsmalloc memory allocator
|
|
|
|
*
|
|
|
|
* Copyright (C) 2011 Nitin Gupta
|
2014-01-30 23:45:55 +00:00
|
|
|
* Copyright (C) 2012, 2013 Minchan Kim
|
2012-01-09 22:51:56 +00:00
|
|
|
*
|
|
|
|
* This code is released using a dual license strategy: BSD/GPL
|
|
|
|
* You can choose the license that better fits your requirements.
|
|
|
|
*
|
|
|
|
* Released under the terms of 3-clause BSD License
|
|
|
|
* Released under the terms of GNU General Public License Version 2.0
|
|
|
|
*/
|
|
|
|
|
2012-06-10 00:41:14 +00:00
|
|
|
/*
|
|
|
|
* Following is how we use various fields and flags of underlying
|
|
|
|
* struct page(s) to form a zspage.
|
|
|
|
*
|
|
|
|
* Usage of struct page fields:
|
|
|
|
* page->first_page: points to the first component (0-order) page
|
|
|
|
* page->index (union with page->freelist): offset of the first object
|
|
|
|
* starting in this page. For the first page, this is
|
|
|
|
* always 0, so we use this field (aka freelist) to point
|
|
|
|
* to the first free object in zspage.
|
|
|
|
* page->lru: links together all component pages (except the first page)
|
|
|
|
* of a zspage
|
|
|
|
*
|
|
|
|
* For _first_ page only:
|
|
|
|
*
|
|
|
|
* page->private (union with page->first_page): refers to the
|
|
|
|
* component page after the first page
|
2015-04-15 23:15:39 +00:00
|
|
|
* If the page is first_page for huge object, it stores handle.
|
|
|
|
* Look at size_class->huge.
|
2012-06-10 00:41:14 +00:00
|
|
|
* page->freelist: points to the first free object in zspage.
|
|
|
|
* Free objects are linked together using in-place
|
|
|
|
* metadata.
|
|
|
|
* page->objects: maximum number of objects we can store in this
|
|
|
|
* zspage (class->zspage_order * PAGE_SIZE / class->size)
|
|
|
|
* page->lru: links together first pages of various zspages.
|
|
|
|
* Basically forming list of zspages in a fullness group.
|
|
|
|
* page->mapping: class index and fullness group of the zspage
|
|
|
|
*
|
|
|
|
* Usage of struct page flags:
|
|
|
|
* PG_private: identifies the first component page
|
|
|
|
* PG_private2: identifies the last component page
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2012-01-09 22:51:56 +00:00
|
|
|
#ifdef CONFIG_ZSMALLOC_DEBUG
|
|
|
|
#define DEBUG
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kernel.h>
|
2015-04-15 23:15:30 +00:00
|
|
|
#include <linux/sched.h>
|
2012-01-09 22:51:56 +00:00
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <asm/tlbflush.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <linux/cpumask.h>
|
|
|
|
#include <linux/cpu.h>
|
2012-02-13 14:47:49 +00:00
|
|
|
#include <linux/vmalloc.h>
|
2012-07-18 16:55:55 +00:00
|
|
|
#include <linux/hardirq.h>
|
2012-08-08 06:12:17 +00:00
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/types.h>
|
2015-02-12 23:00:54 +00:00
|
|
|
#include <linux/debugfs.h>
|
2014-01-30 23:45:50 +00:00
|
|
|
#include <linux/zsmalloc.h>
|
2014-08-06 23:08:38 +00:00
|
|
|
#include <linux/zpool.h>
|
2012-08-08 06:12:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This must be power of 2 and greater than of equal to sizeof(link_free).
|
|
|
|
* These two conditions ensure that any 'struct link_free' itself doesn't
|
|
|
|
* span more than 1 page which avoids complex case of mapping 2 pages simply
|
|
|
|
* to restore link_free pointer values.
|
|
|
|
*/
|
|
|
|
#define ZS_ALIGN 8
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A single 'zspage' is composed of up to 2^N discontiguous 0-order (single)
|
|
|
|
* pages. ZS_MAX_ZSPAGE_ORDER defines upper limit on N.
|
|
|
|
*/
|
|
|
|
#define ZS_MAX_ZSPAGE_ORDER 2
|
|
|
|
#define ZS_MAX_PAGES_PER_ZSPAGE (_AC(1, UL) << ZS_MAX_ZSPAGE_ORDER)
|
|
|
|
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
#define ZS_HANDLE_SIZE (sizeof(unsigned long))
|
|
|
|
|
2012-08-08 06:12:17 +00:00
|
|
|
/*
|
|
|
|
* Object location (<PFN>, <obj_idx>) is encoded as
|
2013-12-11 02:04:37 +00:00
|
|
|
* as single (unsigned long) handle value.
|
2012-08-08 06:12:17 +00:00
|
|
|
*
|
|
|
|
* Note that object index <obj_idx> is relative to system
|
|
|
|
* page <PFN> it is stored in, so for each sub-page belonging
|
|
|
|
* to a zspage, obj_idx starts with 0.
|
|
|
|
*
|
|
|
|
* This is made more complicated by various memory models and PAE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef MAX_PHYSMEM_BITS
|
|
|
|
#ifdef CONFIG_HIGHMEM64G
|
|
|
|
#define MAX_PHYSMEM_BITS 36
|
|
|
|
#else /* !CONFIG_HIGHMEM64G */
|
|
|
|
/*
|
|
|
|
* If this definition of MAX_PHYSMEM_BITS is used, OBJ_INDEX_BITS will just
|
|
|
|
* be PAGE_SHIFT
|
|
|
|
*/
|
|
|
|
#define MAX_PHYSMEM_BITS BITS_PER_LONG
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#define _PFN_BITS (MAX_PHYSMEM_BITS - PAGE_SHIFT)
|
2015-04-15 23:15:30 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Memory for allocating for handle keeps object position by
|
|
|
|
* encoding <page, obj_idx> and the encoded value has a room
|
|
|
|
* in least bit(ie, look at obj_to_location).
|
|
|
|
* We use the bit to synchronize between object access by
|
|
|
|
* user and migration.
|
|
|
|
*/
|
|
|
|
#define HANDLE_PIN_BIT 0
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Head in allocated object should have OBJ_ALLOCATED_TAG
|
|
|
|
* to identify the object was allocated or not.
|
|
|
|
* It's okay to add the status bit in the least bit because
|
|
|
|
* header keeps handle which is 4byte-aligned address so we
|
|
|
|
* have room for two bit at least.
|
|
|
|
*/
|
|
|
|
#define OBJ_ALLOCATED_TAG 1
|
|
|
|
#define OBJ_TAG_BITS 1
|
|
|
|
#define OBJ_INDEX_BITS (BITS_PER_LONG - _PFN_BITS - OBJ_TAG_BITS)
|
2012-08-08 06:12:17 +00:00
|
|
|
#define OBJ_INDEX_MASK ((_AC(1, UL) << OBJ_INDEX_BITS) - 1)
|
|
|
|
|
|
|
|
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
|
|
|
|
/* ZS_MIN_ALLOC_SIZE must be multiple of ZS_ALIGN */
|
|
|
|
#define ZS_MIN_ALLOC_SIZE \
|
|
|
|
MAX(32, (ZS_MAX_PAGES_PER_ZSPAGE << PAGE_SHIFT >> OBJ_INDEX_BITS))
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
/* each chunk includes extra space to keep handle */
|
2015-04-15 23:15:39 +00:00
|
|
|
#define ZS_MAX_ALLOC_SIZE PAGE_SIZE
|
2012-08-08 06:12:17 +00:00
|
|
|
|
|
|
|
/*
|
2014-06-04 23:11:08 +00:00
|
|
|
* On systems with 4K page size, this gives 255 size classes! There is a
|
2012-08-08 06:12:17 +00:00
|
|
|
* trader-off here:
|
|
|
|
* - Large number of size classes is potentially wasteful as free page are
|
|
|
|
* spread across these classes
|
|
|
|
* - Small number of size classes causes large internal fragmentation
|
|
|
|
* - Probably its better to use specific size classes (empirically
|
|
|
|
* determined). NOTE: all those class sizes must be set as multiple of
|
|
|
|
* ZS_ALIGN to make sure link_free itself never has to span 2 pages.
|
|
|
|
*
|
|
|
|
* ZS_MIN_ALLOC_SIZE and ZS_SIZE_CLASS_DELTA must be multiple of ZS_ALIGN
|
|
|
|
* (reason above)
|
|
|
|
*/
|
2013-01-25 17:46:18 +00:00
|
|
|
#define ZS_SIZE_CLASS_DELTA (PAGE_SIZE >> 8)
|
2012-08-08 06:12:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We do not maintain any list for completely empty or full pages
|
|
|
|
*/
|
|
|
|
enum fullness_group {
|
|
|
|
ZS_ALMOST_FULL,
|
|
|
|
ZS_ALMOST_EMPTY,
|
|
|
|
_ZS_NR_FULLNESS_GROUPS,
|
|
|
|
|
|
|
|
ZS_EMPTY,
|
|
|
|
ZS_FULL
|
|
|
|
};
|
|
|
|
|
2015-02-12 23:00:54 +00:00
|
|
|
enum zs_stat_type {
|
|
|
|
OBJ_ALLOCATED,
|
|
|
|
OBJ_USED,
|
2015-04-15 23:15:42 +00:00
|
|
|
CLASS_ALMOST_FULL,
|
|
|
|
CLASS_ALMOST_EMPTY,
|
2015-02-12 23:00:54 +00:00
|
|
|
NR_ZS_STAT_TYPE,
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_ZSMALLOC_STAT
|
|
|
|
|
|
|
|
static struct dentry *zs_stat_root;
|
|
|
|
|
|
|
|
struct zs_size_stat {
|
|
|
|
unsigned long objs[NR_ZS_STAT_TYPE];
|
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2014-12-13 00:57:01 +00:00
|
|
|
/*
|
|
|
|
* number of size_classes
|
|
|
|
*/
|
|
|
|
static int zs_size_classes;
|
|
|
|
|
2012-08-08 06:12:17 +00:00
|
|
|
/*
|
|
|
|
* We assign a page to ZS_ALMOST_EMPTY fullness group when:
|
|
|
|
* n <= N / f, where
|
|
|
|
* n = number of allocated objects
|
|
|
|
* N = total number of objects zspage can store
|
2014-10-09 22:29:59 +00:00
|
|
|
* f = fullness_threshold_frac
|
2012-08-08 06:12:17 +00:00
|
|
|
*
|
|
|
|
* Similarly, we assign zspage to:
|
|
|
|
* ZS_ALMOST_FULL when n > N / f
|
|
|
|
* ZS_EMPTY when n == 0
|
|
|
|
* ZS_FULL when n == N
|
|
|
|
*
|
|
|
|
* (see: fix_fullness_group())
|
|
|
|
*/
|
|
|
|
static const int fullness_threshold_frac = 4;
|
|
|
|
|
|
|
|
struct size_class {
|
|
|
|
/*
|
|
|
|
* Size of objects stored in this class. Must be multiple
|
|
|
|
* of ZS_ALIGN.
|
|
|
|
*/
|
|
|
|
int size;
|
|
|
|
unsigned int index;
|
|
|
|
|
|
|
|
/* Number of PAGE_SIZE sized pages to combine to form a 'zspage' */
|
|
|
|
int pages_per_zspage;
|
2015-04-15 23:15:39 +00:00
|
|
|
/* huge object: pages_per_zspage == 1 && maxobj_per_zspage == 1 */
|
|
|
|
bool huge;
|
2012-08-08 06:12:17 +00:00
|
|
|
|
2015-02-12 23:00:54 +00:00
|
|
|
#ifdef CONFIG_ZSMALLOC_STAT
|
|
|
|
struct zs_size_stat stats;
|
|
|
|
#endif
|
|
|
|
|
2012-08-08 06:12:17 +00:00
|
|
|
spinlock_t lock;
|
|
|
|
|
|
|
|
struct page *fullness_list[_ZS_NR_FULLNESS_GROUPS];
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Placed within free objects to form a singly linked list.
|
|
|
|
* For every zspage, first_page->freelist gives head of this list.
|
|
|
|
*
|
|
|
|
* This must be power of 2 and less than or equal to ZS_ALIGN
|
|
|
|
*/
|
|
|
|
struct link_free {
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
union {
|
|
|
|
/*
|
|
|
|
* Position of next free chunk (encodes <PFN, obj_idx>)
|
|
|
|
* It's valid for non-allocated object
|
|
|
|
*/
|
|
|
|
void *next;
|
|
|
|
/*
|
|
|
|
* Handle of allocated object.
|
|
|
|
*/
|
|
|
|
unsigned long handle;
|
|
|
|
};
|
2012-08-08 06:12:17 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct zs_pool {
|
2015-02-12 23:00:54 +00:00
|
|
|
char *name;
|
|
|
|
|
2014-12-13 00:57:01 +00:00
|
|
|
struct size_class **size_class;
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
struct kmem_cache *handle_cachep;
|
2012-08-08 06:12:17 +00:00
|
|
|
|
|
|
|
gfp_t flags; /* allocation flags used when growing pool */
|
UPSTREAM: zsmalloc: move pages_allocated to zs_pool
(cherry-pick from commit 13de8933c96b4557f667c337676f05274e017f83)
Currently, zram has no feature to limit memory so theoretically zram can
deplete system memory. Users have asked for a limit several times as even
without exhaustion zram makes it hard to control memory usage of the
platform. This patchset adds the feature.
Patch 1 makes zs_get_total_size_bytes faster because it would be used
frequently in later patches for the new feature.
Patch 2 changes zs_get_total_size_bytes's return unit from bytes to page
so that zsmalloc doesn't need unnecessary operation(ie, << PAGE_SHIFT).
Patch 3 adds new feature. I added the feature into zram layer, not
zsmalloc because limiation is zram's requirement, not zsmalloc so any
other user using zsmalloc(ie, zpool) shouldn't affected by unnecessary
branch of zsmalloc. In future, if every users of zsmalloc want the
feature, then, we could move the feature from client side to zsmalloc
easily but vice versa would be painful.
Patch 4 adds news facility to report maximum memory usage of zram so that
this avoids user polling frequently via /sys/block/zram0/ mem_used_total
and ensures transient max are not missed.
This patch (of 4):
pages_allocated has counted in size_class structure and when user of
zsmalloc want to see total_size_bytes, it should gather all of count from
each size_class to report the sum.
It's not bad if user don't see the value often but if user start to see
the value frequently, it would be not a good deal for performance pov.
This patch moves the count from size_class to zs_pool so it could reduce
memory footprint (from [255 * 8byte] to [sizeof(atomic_long_t)]).
Bug: 25951511
Change-Id: I05526575b81c95a12a7f8f0ef05040ed18b5fa6f
Signed-off-by: Minchan Kim <minchan@kernel.org>
Reviewed-by: Dan Streetman <ddstreet@ieee.org>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: <juno.choi@lge.com>
Cc: <seungho1.park@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Reviewed-by: David Horner <ds2horner@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-10-09 22:29:48 +00:00
|
|
|
atomic_long_t pages_allocated;
|
2015-02-12 23:00:54 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_ZSMALLOC_STAT
|
|
|
|
struct dentry *stat_dentry;
|
|
|
|
#endif
|
2012-08-08 06:12:17 +00:00
|
|
|
};
|
2012-01-09 22:51:56 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* A zspage's class index and fullness group
|
|
|
|
* are encoded in its (first)page->mapping
|
|
|
|
*/
|
|
|
|
#define CLASS_IDX_BITS 28
|
|
|
|
#define FULLNESS_BITS 4
|
|
|
|
#define CLASS_IDX_MASK ((1 << CLASS_IDX_BITS) - 1)
|
|
|
|
#define FULLNESS_MASK ((1 << FULLNESS_BITS) - 1)
|
|
|
|
|
2012-07-18 16:55:56 +00:00
|
|
|
struct mapping_area {
|
2013-12-11 02:04:36 +00:00
|
|
|
#ifdef CONFIG_PGTABLE_MAPPING
|
2012-07-18 16:55:56 +00:00
|
|
|
struct vm_struct *vm; /* vm area for mapping object that span pages */
|
|
|
|
#else
|
|
|
|
char *vm_buf; /* copy buffer for objects that span pages */
|
|
|
|
#endif
|
|
|
|
char *vm_addr; /* address of kmap_atomic()'ed pages */
|
|
|
|
enum zs_mapmode vm_mm; /* mapping mode */
|
2015-04-15 23:15:39 +00:00
|
|
|
bool huge;
|
2012-07-18 16:55:56 +00:00
|
|
|
};
|
|
|
|
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
static int create_handle_cache(struct zs_pool *pool)
|
|
|
|
{
|
|
|
|
pool->handle_cachep = kmem_cache_create("zs_handle", ZS_HANDLE_SIZE,
|
|
|
|
0, 0, NULL);
|
|
|
|
return pool->handle_cachep ? 0 : 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void destroy_handle_cache(struct zs_pool *pool)
|
|
|
|
{
|
|
|
|
kmem_cache_destroy(pool->handle_cachep);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long alloc_handle(struct zs_pool *pool)
|
|
|
|
{
|
|
|
|
return (unsigned long)kmem_cache_alloc(pool->handle_cachep,
|
|
|
|
pool->flags & ~__GFP_HIGHMEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_handle(struct zs_pool *pool, unsigned long handle)
|
|
|
|
{
|
|
|
|
kmem_cache_free(pool->handle_cachep, (void *)handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void record_obj(unsigned long handle, unsigned long obj)
|
|
|
|
{
|
|
|
|
*(unsigned long *)handle = obj;
|
|
|
|
}
|
|
|
|
|
2014-08-06 23:08:38 +00:00
|
|
|
/* zpool driver */
|
|
|
|
|
|
|
|
#ifdef CONFIG_ZPOOL
|
|
|
|
|
2015-02-12 23:00:51 +00:00
|
|
|
static void *zs_zpool_create(char *name, gfp_t gfp, struct zpool_ops *zpool_ops)
|
2014-08-06 23:08:38 +00:00
|
|
|
{
|
2015-02-12 23:00:51 +00:00
|
|
|
return zs_create_pool(name, gfp);
|
2014-08-06 23:08:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void zs_zpool_destroy(void *pool)
|
|
|
|
{
|
|
|
|
zs_destroy_pool(pool);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int zs_zpool_malloc(void *pool, size_t size, gfp_t gfp,
|
|
|
|
unsigned long *handle)
|
|
|
|
{
|
|
|
|
*handle = zs_malloc(pool, size);
|
|
|
|
return *handle ? 0 : -1;
|
|
|
|
}
|
|
|
|
static void zs_zpool_free(void *pool, unsigned long handle)
|
|
|
|
{
|
|
|
|
zs_free(pool, handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int zs_zpool_shrink(void *pool, unsigned int pages,
|
|
|
|
unsigned int *reclaimed)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *zs_zpool_map(void *pool, unsigned long handle,
|
|
|
|
enum zpool_mapmode mm)
|
|
|
|
{
|
|
|
|
enum zs_mapmode zs_mm;
|
|
|
|
|
|
|
|
switch (mm) {
|
|
|
|
case ZPOOL_MM_RO:
|
|
|
|
zs_mm = ZS_MM_RO;
|
|
|
|
break;
|
|
|
|
case ZPOOL_MM_WO:
|
|
|
|
zs_mm = ZS_MM_WO;
|
|
|
|
break;
|
|
|
|
case ZPOOL_MM_RW: /* fallthru */
|
|
|
|
default:
|
|
|
|
zs_mm = ZS_MM_RW;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return zs_map_object(pool, handle, zs_mm);
|
|
|
|
}
|
|
|
|
static void zs_zpool_unmap(void *pool, unsigned long handle)
|
|
|
|
{
|
|
|
|
zs_unmap_object(pool, handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
static u64 zs_zpool_total_size(void *pool)
|
|
|
|
{
|
2014-10-09 22:29:50 +00:00
|
|
|
return zs_get_total_pages(pool) << PAGE_SHIFT;
|
2014-08-06 23:08:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct zpool_driver zs_zpool_driver = {
|
|
|
|
.type = "zsmalloc",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.create = zs_zpool_create,
|
|
|
|
.destroy = zs_zpool_destroy,
|
|
|
|
.malloc = zs_zpool_malloc,
|
|
|
|
.free = zs_zpool_free,
|
|
|
|
.shrink = zs_zpool_shrink,
|
|
|
|
.map = zs_zpool_map,
|
|
|
|
.unmap = zs_zpool_unmap,
|
|
|
|
.total_size = zs_zpool_total_size,
|
|
|
|
};
|
|
|
|
|
2014-08-29 22:18:40 +00:00
|
|
|
MODULE_ALIAS("zpool-zsmalloc");
|
2014-08-06 23:08:38 +00:00
|
|
|
#endif /* CONFIG_ZPOOL */
|
|
|
|
|
2015-04-15 23:15:42 +00:00
|
|
|
static unsigned int get_maxobj_per_zspage(int size, int pages_per_zspage)
|
|
|
|
{
|
|
|
|
return pages_per_zspage * PAGE_SIZE / size;
|
|
|
|
}
|
|
|
|
|
2012-01-09 22:51:56 +00:00
|
|
|
/* per-cpu VM mapping areas for zspage accesses that cross page boundaries */
|
|
|
|
static DEFINE_PER_CPU(struct mapping_area, zs_map_area);
|
|
|
|
|
|
|
|
static int is_first_page(struct page *page)
|
|
|
|
{
|
2012-04-25 06:23:09 +00:00
|
|
|
return PagePrivate(page);
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int is_last_page(struct page *page)
|
|
|
|
{
|
2012-04-25 06:23:09 +00:00
|
|
|
return PagePrivate2(page);
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void get_zspage_mapping(struct page *page, unsigned int *class_idx,
|
|
|
|
enum fullness_group *fullness)
|
|
|
|
{
|
|
|
|
unsigned long m;
|
|
|
|
BUG_ON(!is_first_page(page));
|
|
|
|
|
|
|
|
m = (unsigned long)page->mapping;
|
|
|
|
*fullness = m & FULLNESS_MASK;
|
|
|
|
*class_idx = (m >> FULLNESS_BITS) & CLASS_IDX_MASK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_zspage_mapping(struct page *page, unsigned int class_idx,
|
|
|
|
enum fullness_group fullness)
|
|
|
|
{
|
|
|
|
unsigned long m;
|
|
|
|
BUG_ON(!is_first_page(page));
|
|
|
|
|
|
|
|
m = ((class_idx & CLASS_IDX_MASK) << FULLNESS_BITS) |
|
|
|
|
(fullness & FULLNESS_MASK);
|
|
|
|
page->mapping = (struct address_space *)m;
|
|
|
|
}
|
|
|
|
|
2013-12-11 02:04:37 +00:00
|
|
|
/*
|
|
|
|
* zsmalloc divides the pool into various size classes where each
|
|
|
|
* class maintains a list of zspages where each zspage is divided
|
|
|
|
* into equal sized chunks. Each allocation falls into one of these
|
|
|
|
* classes depending on its size. This function returns index of the
|
|
|
|
* size class which has chunk size big enough to hold the give size.
|
|
|
|
*/
|
2012-01-09 22:51:56 +00:00
|
|
|
static int get_size_class_index(int size)
|
|
|
|
{
|
|
|
|
int idx = 0;
|
|
|
|
|
|
|
|
if (likely(size > ZS_MIN_ALLOC_SIZE))
|
|
|
|
idx = DIV_ROUND_UP(size - ZS_MIN_ALLOC_SIZE,
|
|
|
|
ZS_SIZE_CLASS_DELTA);
|
|
|
|
|
2015-04-15 23:15:39 +00:00
|
|
|
return min(zs_size_classes - 1, idx);
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
2015-04-15 23:15:42 +00:00
|
|
|
#ifdef CONFIG_ZSMALLOC_STAT
|
|
|
|
|
|
|
|
static inline void zs_stat_inc(struct size_class *class,
|
|
|
|
enum zs_stat_type type, unsigned long cnt)
|
|
|
|
{
|
|
|
|
class->stats.objs[type] += cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void zs_stat_dec(struct size_class *class,
|
|
|
|
enum zs_stat_type type, unsigned long cnt)
|
|
|
|
{
|
|
|
|
class->stats.objs[type] -= cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long zs_stat_get(struct size_class *class,
|
|
|
|
enum zs_stat_type type)
|
|
|
|
{
|
|
|
|
return class->stats.objs[type];
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init zs_stat_init(void)
|
|
|
|
{
|
|
|
|
if (!debugfs_initialized())
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
zs_stat_root = debugfs_create_dir("zsmalloc", NULL);
|
|
|
|
if (!zs_stat_root)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit zs_stat_exit(void)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(zs_stat_root);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int zs_stats_size_show(struct seq_file *s, void *v)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct zs_pool *pool = s->private;
|
|
|
|
struct size_class *class;
|
|
|
|
int objs_per_zspage;
|
|
|
|
unsigned long class_almost_full, class_almost_empty;
|
|
|
|
unsigned long obj_allocated, obj_used, pages_used;
|
|
|
|
unsigned long total_class_almost_full = 0, total_class_almost_empty = 0;
|
|
|
|
unsigned long total_objs = 0, total_used_objs = 0, total_pages = 0;
|
|
|
|
|
|
|
|
seq_printf(s, " %5s %5s %11s %12s %13s %10s %10s %16s\n",
|
|
|
|
"class", "size", "almost_full", "almost_empty",
|
|
|
|
"obj_allocated", "obj_used", "pages_used",
|
|
|
|
"pages_per_zspage");
|
|
|
|
|
|
|
|
for (i = 0; i < zs_size_classes; i++) {
|
|
|
|
class = pool->size_class[i];
|
|
|
|
|
|
|
|
if (class->index != i)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
spin_lock(&class->lock);
|
|
|
|
class_almost_full = zs_stat_get(class, CLASS_ALMOST_FULL);
|
|
|
|
class_almost_empty = zs_stat_get(class, CLASS_ALMOST_EMPTY);
|
|
|
|
obj_allocated = zs_stat_get(class, OBJ_ALLOCATED);
|
|
|
|
obj_used = zs_stat_get(class, OBJ_USED);
|
|
|
|
spin_unlock(&class->lock);
|
|
|
|
|
|
|
|
objs_per_zspage = get_maxobj_per_zspage(class->size,
|
|
|
|
class->pages_per_zspage);
|
|
|
|
pages_used = obj_allocated / objs_per_zspage *
|
|
|
|
class->pages_per_zspage;
|
|
|
|
|
|
|
|
seq_printf(s, " %5u %5u %11lu %12lu %13lu %10lu %10lu %16d\n",
|
|
|
|
i, class->size, class_almost_full, class_almost_empty,
|
|
|
|
obj_allocated, obj_used, pages_used,
|
|
|
|
class->pages_per_zspage);
|
|
|
|
|
|
|
|
total_class_almost_full += class_almost_full;
|
|
|
|
total_class_almost_empty += class_almost_empty;
|
|
|
|
total_objs += obj_allocated;
|
|
|
|
total_used_objs += obj_used;
|
|
|
|
total_pages += pages_used;
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_puts(s, "\n");
|
|
|
|
seq_printf(s, " %5s %5s %11lu %12lu %13lu %10lu %10lu\n",
|
|
|
|
"Total", "", total_class_almost_full,
|
|
|
|
total_class_almost_empty, total_objs,
|
|
|
|
total_used_objs, total_pages);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int zs_stats_size_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, zs_stats_size_show, inode->i_private);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations zs_stat_size_ops = {
|
|
|
|
.open = zs_stats_size_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int zs_pool_stat_create(char *name, struct zs_pool *pool)
|
|
|
|
{
|
|
|
|
struct dentry *entry;
|
|
|
|
|
|
|
|
if (!zs_stat_root)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
entry = debugfs_create_dir(name, zs_stat_root);
|
|
|
|
if (!entry) {
|
|
|
|
pr_warn("debugfs dir <%s> creation failed\n", name);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
pool->stat_dentry = entry;
|
|
|
|
|
|
|
|
entry = debugfs_create_file("classes", S_IFREG | S_IRUGO,
|
|
|
|
pool->stat_dentry, pool, &zs_stat_size_ops);
|
|
|
|
if (!entry) {
|
|
|
|
pr_warn("%s: debugfs file entry <%s> creation failed\n",
|
|
|
|
name, "classes");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void zs_pool_stat_destroy(struct zs_pool *pool)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(pool->stat_dentry);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* CONFIG_ZSMALLOC_STAT */
|
|
|
|
|
|
|
|
static inline void zs_stat_inc(struct size_class *class,
|
|
|
|
enum zs_stat_type type, unsigned long cnt)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void zs_stat_dec(struct size_class *class,
|
|
|
|
enum zs_stat_type type, unsigned long cnt)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long zs_stat_get(struct size_class *class,
|
|
|
|
enum zs_stat_type type)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init zs_stat_init(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit zs_stat_exit(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int zs_pool_stat_create(char *name, struct zs_pool *pool)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void zs_pool_stat_destroy(struct zs_pool *pool)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2013-12-11 02:04:37 +00:00
|
|
|
/*
|
|
|
|
* For each size class, zspages are divided into different groups
|
|
|
|
* depending on how "full" they are. This was done so that we could
|
|
|
|
* easily find empty or nearly empty zspages when we try to shrink
|
|
|
|
* the pool (not yet implemented). This function returns fullness
|
|
|
|
* status of the given page.
|
|
|
|
*/
|
2012-01-09 22:51:56 +00:00
|
|
|
static enum fullness_group get_fullness_group(struct page *page)
|
|
|
|
{
|
|
|
|
int inuse, max_objects;
|
|
|
|
enum fullness_group fg;
|
|
|
|
BUG_ON(!is_first_page(page));
|
|
|
|
|
|
|
|
inuse = page->inuse;
|
|
|
|
max_objects = page->objects;
|
|
|
|
|
|
|
|
if (inuse == 0)
|
|
|
|
fg = ZS_EMPTY;
|
|
|
|
else if (inuse == max_objects)
|
|
|
|
fg = ZS_FULL;
|
2015-04-15 23:15:33 +00:00
|
|
|
else if (inuse <= 3 * max_objects / fullness_threshold_frac)
|
2012-01-09 22:51:56 +00:00
|
|
|
fg = ZS_ALMOST_EMPTY;
|
|
|
|
else
|
|
|
|
fg = ZS_ALMOST_FULL;
|
|
|
|
|
|
|
|
return fg;
|
|
|
|
}
|
|
|
|
|
2013-12-11 02:04:37 +00:00
|
|
|
/*
|
|
|
|
* Each size class maintains various freelists and zspages are assigned
|
|
|
|
* to one of these freelists based on the number of live objects they
|
|
|
|
* have. This functions inserts the given zspage into the freelist
|
|
|
|
* identified by <class, fullness_group>.
|
|
|
|
*/
|
2012-01-09 22:51:56 +00:00
|
|
|
static void insert_zspage(struct page *page, struct size_class *class,
|
|
|
|
enum fullness_group fullness)
|
|
|
|
{
|
|
|
|
struct page **head;
|
|
|
|
|
|
|
|
BUG_ON(!is_first_page(page));
|
|
|
|
|
|
|
|
if (fullness >= _ZS_NR_FULLNESS_GROUPS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
head = &class->fullness_list[fullness];
|
|
|
|
if (*head)
|
|
|
|
list_add_tail(&page->lru, &(*head)->lru);
|
|
|
|
|
|
|
|
*head = page;
|
2015-04-15 23:15:42 +00:00
|
|
|
zs_stat_inc(class, fullness == ZS_ALMOST_EMPTY ?
|
|
|
|
CLASS_ALMOST_EMPTY : CLASS_ALMOST_FULL, 1);
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
2013-12-11 02:04:37 +00:00
|
|
|
/*
|
|
|
|
* This function removes the given zspage from the freelist identified
|
|
|
|
* by <class, fullness_group>.
|
|
|
|
*/
|
2012-01-09 22:51:56 +00:00
|
|
|
static void remove_zspage(struct page *page, struct size_class *class,
|
|
|
|
enum fullness_group fullness)
|
|
|
|
{
|
|
|
|
struct page **head;
|
|
|
|
|
|
|
|
BUG_ON(!is_first_page(page));
|
|
|
|
|
|
|
|
if (fullness >= _ZS_NR_FULLNESS_GROUPS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
head = &class->fullness_list[fullness];
|
|
|
|
BUG_ON(!*head);
|
|
|
|
if (list_empty(&(*head)->lru))
|
|
|
|
*head = NULL;
|
|
|
|
else if (*head == page)
|
|
|
|
*head = (struct page *)list_entry((*head)->lru.next,
|
|
|
|
struct page, lru);
|
|
|
|
|
|
|
|
list_del_init(&page->lru);
|
2015-04-15 23:15:42 +00:00
|
|
|
zs_stat_dec(class, fullness == ZS_ALMOST_EMPTY ?
|
|
|
|
CLASS_ALMOST_EMPTY : CLASS_ALMOST_FULL, 1);
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
2013-12-11 02:04:37 +00:00
|
|
|
/*
|
|
|
|
* Each size class maintains zspages in different fullness groups depending
|
|
|
|
* on the number of live objects they contain. When allocating or freeing
|
|
|
|
* objects, the fullness status of the page can change, say, from ALMOST_FULL
|
|
|
|
* to ALMOST_EMPTY when freeing an object. This function checks if such
|
|
|
|
* a status change has occurred for the given page and accordingly moves the
|
|
|
|
* page from the freelist of the old fullness group to that of the new
|
|
|
|
* fullness group.
|
|
|
|
*/
|
2015-04-15 23:15:26 +00:00
|
|
|
static enum fullness_group fix_fullness_group(struct size_class *class,
|
2012-01-09 22:51:56 +00:00
|
|
|
struct page *page)
|
|
|
|
{
|
|
|
|
int class_idx;
|
|
|
|
enum fullness_group currfg, newfg;
|
|
|
|
|
|
|
|
BUG_ON(!is_first_page(page));
|
|
|
|
|
|
|
|
get_zspage_mapping(page, &class_idx, &currfg);
|
|
|
|
newfg = get_fullness_group(page);
|
|
|
|
if (newfg == currfg)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
remove_zspage(page, class, currfg);
|
|
|
|
insert_zspage(page, class, newfg);
|
|
|
|
set_zspage_mapping(page, class_idx, newfg);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return newfg;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have to decide on how many pages to link together
|
|
|
|
* to form a zspage for each size class. This is important
|
|
|
|
* to reduce wastage due to unusable space left at end of
|
|
|
|
* each zspage which is given as:
|
2015-04-15 23:15:49 +00:00
|
|
|
* wastage = Zp % class_size
|
|
|
|
* usage = Zp - wastage
|
2012-01-09 22:51:56 +00:00
|
|
|
* where Zp = zspage size = k * PAGE_SIZE where k = 1, 2, ...
|
|
|
|
*
|
|
|
|
* For example, for size class of 3/8 * PAGE_SIZE, we should
|
|
|
|
* link together 3 PAGE_SIZE sized pages to form a zspage
|
|
|
|
* since then we can perfectly fit in 8 such objects.
|
|
|
|
*/
|
2012-05-03 06:40:39 +00:00
|
|
|
static int get_pages_per_zspage(int class_size)
|
2012-01-09 22:51:56 +00:00
|
|
|
{
|
|
|
|
int i, max_usedpc = 0;
|
|
|
|
/* zspage order which gives maximum used size per KB */
|
|
|
|
int max_usedpc_order = 1;
|
|
|
|
|
2012-03-05 17:33:21 +00:00
|
|
|
for (i = 1; i <= ZS_MAX_PAGES_PER_ZSPAGE; i++) {
|
2012-01-09 22:51:56 +00:00
|
|
|
int zspage_size;
|
|
|
|
int waste, usedpc;
|
|
|
|
|
|
|
|
zspage_size = i * PAGE_SIZE;
|
|
|
|
waste = zspage_size % class_size;
|
|
|
|
usedpc = (zspage_size - waste) * 100 / zspage_size;
|
|
|
|
|
|
|
|
if (usedpc > max_usedpc) {
|
|
|
|
max_usedpc = usedpc;
|
|
|
|
max_usedpc_order = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return max_usedpc_order;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A single 'zspage' is composed of many system pages which are
|
|
|
|
* linked together using fields in struct page. This function finds
|
|
|
|
* the first/head page, given any component page of a zspage.
|
|
|
|
*/
|
|
|
|
static struct page *get_first_page(struct page *page)
|
|
|
|
{
|
|
|
|
if (is_first_page(page))
|
|
|
|
return page;
|
|
|
|
else
|
|
|
|
return page->first_page;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct page *get_next_page(struct page *page)
|
|
|
|
{
|
|
|
|
struct page *next;
|
|
|
|
|
|
|
|
if (is_last_page(page))
|
|
|
|
next = NULL;
|
|
|
|
else if (is_first_page(page))
|
2013-07-12 07:08:13 +00:00
|
|
|
next = (struct page *)page_private(page);
|
2012-01-09 22:51:56 +00:00
|
|
|
else
|
|
|
|
next = list_entry(page->lru.next, struct page, lru);
|
|
|
|
|
|
|
|
return next;
|
|
|
|
}
|
|
|
|
|
2013-11-04 23:51:51 +00:00
|
|
|
/*
|
|
|
|
* Encode <page, obj_idx> as a single handle value.
|
2015-04-15 23:15:30 +00:00
|
|
|
* We use the least bit of handle for tagging.
|
2013-11-04 23:51:51 +00:00
|
|
|
*/
|
2015-04-15 23:15:30 +00:00
|
|
|
static void *location_to_obj(struct page *page, unsigned long obj_idx)
|
2012-01-09 22:51:56 +00:00
|
|
|
{
|
2015-04-15 23:15:30 +00:00
|
|
|
unsigned long obj;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
|
|
|
if (!page) {
|
|
|
|
BUG_ON(obj_idx);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-04-15 23:15:30 +00:00
|
|
|
obj = page_to_pfn(page) << OBJ_INDEX_BITS;
|
|
|
|
obj |= ((obj_idx) & OBJ_INDEX_MASK);
|
|
|
|
obj <<= OBJ_TAG_BITS;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2015-04-15 23:15:30 +00:00
|
|
|
return (void *)obj;
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
2013-11-04 23:51:51 +00:00
|
|
|
/*
|
|
|
|
* Decode <page, obj_idx> pair from the given object handle. We adjust the
|
|
|
|
* decoded obj_idx back to its original value since it was adjusted in
|
2015-04-15 23:15:30 +00:00
|
|
|
* location_to_obj().
|
2013-11-04 23:51:51 +00:00
|
|
|
*/
|
2015-04-15 23:15:30 +00:00
|
|
|
static void obj_to_location(unsigned long obj, struct page **page,
|
2012-01-09 22:51:56 +00:00
|
|
|
unsigned long *obj_idx)
|
|
|
|
{
|
2015-04-15 23:15:30 +00:00
|
|
|
obj >>= OBJ_TAG_BITS;
|
|
|
|
*page = pfn_to_page(obj >> OBJ_INDEX_BITS);
|
|
|
|
*obj_idx = (obj & OBJ_INDEX_MASK);
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
static unsigned long handle_to_obj(unsigned long handle)
|
|
|
|
{
|
|
|
|
return *(unsigned long *)handle;
|
|
|
|
}
|
|
|
|
|
2015-04-15 23:15:39 +00:00
|
|
|
static unsigned long obj_to_head(struct size_class *class, struct page *page,
|
|
|
|
void *obj)
|
2015-04-15 23:15:30 +00:00
|
|
|
{
|
2015-04-15 23:15:39 +00:00
|
|
|
if (class->huge) {
|
|
|
|
VM_BUG_ON(!is_first_page(page));
|
|
|
|
return *(unsigned long *)page_private(page);
|
|
|
|
} else
|
|
|
|
return *(unsigned long *)obj;
|
2015-04-15 23:15:30 +00:00
|
|
|
}
|
|
|
|
|
2012-01-09 22:51:56 +00:00
|
|
|
static unsigned long obj_idx_to_offset(struct page *page,
|
|
|
|
unsigned long obj_idx, int class_size)
|
|
|
|
{
|
|
|
|
unsigned long off = 0;
|
|
|
|
|
|
|
|
if (!is_first_page(page))
|
|
|
|
off = page->index;
|
|
|
|
|
|
|
|
return off + obj_idx * class_size;
|
|
|
|
}
|
|
|
|
|
2015-04-15 23:15:30 +00:00
|
|
|
static inline int trypin_tag(unsigned long handle)
|
|
|
|
{
|
|
|
|
unsigned long *ptr = (unsigned long *)handle;
|
|
|
|
|
|
|
|
return !test_and_set_bit_lock(HANDLE_PIN_BIT, ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pin_tag(unsigned long handle)
|
|
|
|
{
|
|
|
|
while (!trypin_tag(handle));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void unpin_tag(unsigned long handle)
|
|
|
|
{
|
|
|
|
unsigned long *ptr = (unsigned long *)handle;
|
|
|
|
|
|
|
|
clear_bit_unlock(HANDLE_PIN_BIT, ptr);
|
|
|
|
}
|
|
|
|
|
2012-04-02 14:13:56 +00:00
|
|
|
static void reset_page(struct page *page)
|
|
|
|
{
|
|
|
|
clear_bit(PG_private, &page->flags);
|
|
|
|
clear_bit(PG_private_2, &page->flags);
|
|
|
|
set_page_private(page, 0);
|
|
|
|
page->mapping = NULL;
|
|
|
|
page->freelist = NULL;
|
2013-02-23 00:34:59 +00:00
|
|
|
page_mapcount_reset(page);
|
2012-04-02 14:13:56 +00:00
|
|
|
}
|
|
|
|
|
2012-01-09 22:51:56 +00:00
|
|
|
static void free_zspage(struct page *first_page)
|
|
|
|
{
|
2012-04-02 14:13:56 +00:00
|
|
|
struct page *nextp, *tmp, *head_extra;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
|
|
|
BUG_ON(!is_first_page(first_page));
|
|
|
|
BUG_ON(first_page->inuse);
|
|
|
|
|
2012-04-02 14:13:56 +00:00
|
|
|
head_extra = (struct page *)page_private(first_page);
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2012-04-02 14:13:56 +00:00
|
|
|
reset_page(first_page);
|
2012-01-09 22:51:56 +00:00
|
|
|
__free_page(first_page);
|
|
|
|
|
|
|
|
/* zspage with only 1 system page */
|
2012-04-02 14:13:56 +00:00
|
|
|
if (!head_extra)
|
2012-01-09 22:51:56 +00:00
|
|
|
return;
|
|
|
|
|
2012-04-02 14:13:56 +00:00
|
|
|
list_for_each_entry_safe(nextp, tmp, &head_extra->lru, lru) {
|
2012-01-09 22:51:56 +00:00
|
|
|
list_del(&nextp->lru);
|
2012-04-02 14:13:56 +00:00
|
|
|
reset_page(nextp);
|
2012-01-09 22:51:56 +00:00
|
|
|
__free_page(nextp);
|
|
|
|
}
|
2012-04-02 14:13:56 +00:00
|
|
|
reset_page(head_extra);
|
|
|
|
__free_page(head_extra);
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize a newly allocated zspage */
|
|
|
|
static void init_zspage(struct page *first_page, struct size_class *class)
|
|
|
|
{
|
|
|
|
unsigned long off = 0;
|
|
|
|
struct page *page = first_page;
|
|
|
|
|
|
|
|
BUG_ON(!is_first_page(first_page));
|
|
|
|
while (page) {
|
|
|
|
struct page *next_page;
|
|
|
|
struct link_free *link;
|
2014-10-09 22:30:01 +00:00
|
|
|
unsigned int i = 1;
|
2014-12-13 00:56:58 +00:00
|
|
|
void *vaddr;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* page->index stores offset of first object starting
|
|
|
|
* in the page. For the first page, this is always 0,
|
|
|
|
* so we use first_page->index (aka ->freelist) to store
|
|
|
|
* head of corresponding zspage's freelist.
|
|
|
|
*/
|
|
|
|
if (page != first_page)
|
|
|
|
page->index = off;
|
|
|
|
|
2014-12-13 00:56:58 +00:00
|
|
|
vaddr = kmap_atomic(page);
|
|
|
|
link = (struct link_free *)vaddr + off / sizeof(*link);
|
2014-10-09 22:30:01 +00:00
|
|
|
|
|
|
|
while ((off += class->size) < PAGE_SIZE) {
|
2015-04-15 23:15:30 +00:00
|
|
|
link->next = location_to_obj(page, i++);
|
2014-10-09 22:30:01 +00:00
|
|
|
link += class->size / sizeof(*link);
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We now come to the last (full or partial) object on this
|
|
|
|
* page, which must point to the first object on the next
|
|
|
|
* page (if present)
|
|
|
|
*/
|
|
|
|
next_page = get_next_page(page);
|
2015-04-15 23:15:30 +00:00
|
|
|
link->next = location_to_obj(next_page, 0);
|
2014-12-13 00:56:58 +00:00
|
|
|
kunmap_atomic(vaddr);
|
2012-01-09 22:51:56 +00:00
|
|
|
page = next_page;
|
2014-10-09 22:30:01 +00:00
|
|
|
off %= PAGE_SIZE;
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate a zspage for the given size class
|
|
|
|
*/
|
|
|
|
static struct page *alloc_zspage(struct size_class *class, gfp_t flags)
|
|
|
|
{
|
|
|
|
int i, error;
|
2012-06-13 21:03:42 +00:00
|
|
|
struct page *first_page = NULL, *uninitialized_var(prev_page);
|
2012-01-09 22:51:56 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate individual pages and link them together as:
|
|
|
|
* 1. first page->private = first sub-page
|
|
|
|
* 2. all sub-pages are linked together using page->lru
|
|
|
|
* 3. each sub-page is linked to the first page using page->first_page
|
|
|
|
*
|
|
|
|
* For each size class, First/Head pages are linked together using
|
|
|
|
* page->lru. Also, we set PG_private to identify the first page
|
|
|
|
* (i.e. no other sub-page has this flag set) and PG_private_2 to
|
|
|
|
* identify the last page.
|
|
|
|
*/
|
|
|
|
error = -ENOMEM;
|
2012-05-03 06:40:39 +00:00
|
|
|
for (i = 0; i < class->pages_per_zspage; i++) {
|
2012-06-13 21:03:42 +00:00
|
|
|
struct page *page;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
|
|
|
page = alloc_page(flags);
|
|
|
|
if (!page)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&page->lru);
|
|
|
|
if (i == 0) { /* first page */
|
2012-04-25 06:23:09 +00:00
|
|
|
SetPagePrivate(page);
|
2012-01-09 22:51:56 +00:00
|
|
|
set_page_private(page, 0);
|
|
|
|
first_page = page;
|
|
|
|
first_page->inuse = 0;
|
|
|
|
}
|
|
|
|
if (i == 1)
|
2013-07-12 07:08:13 +00:00
|
|
|
set_page_private(first_page, (unsigned long)page);
|
2012-01-09 22:51:56 +00:00
|
|
|
if (i >= 1)
|
|
|
|
page->first_page = first_page;
|
|
|
|
if (i >= 2)
|
|
|
|
list_add(&page->lru, &prev_page->lru);
|
2012-05-03 06:40:39 +00:00
|
|
|
if (i == class->pages_per_zspage - 1) /* last page */
|
2012-04-25 06:23:09 +00:00
|
|
|
SetPagePrivate2(page);
|
2012-01-09 22:51:56 +00:00
|
|
|
prev_page = page;
|
|
|
|
}
|
|
|
|
|
|
|
|
init_zspage(first_page, class);
|
|
|
|
|
2015-04-15 23:15:30 +00:00
|
|
|
first_page->freelist = location_to_obj(first_page, 0);
|
2012-01-09 22:51:56 +00:00
|
|
|
/* Maximum number of objects we can store in this zspage */
|
2012-05-03 06:40:39 +00:00
|
|
|
first_page->objects = class->pages_per_zspage * PAGE_SIZE / class->size;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
|
|
|
error = 0; /* Success */
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (unlikely(error) && first_page) {
|
|
|
|
free_zspage(first_page);
|
|
|
|
first_page = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return first_page;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct page *find_get_zspage(struct size_class *class)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
for (i = 0; i < _ZS_NR_FULLNESS_GROUPS; i++) {
|
|
|
|
page = class->fullness_list[i];
|
|
|
|
if (page)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
2013-12-11 02:04:36 +00:00
|
|
|
#ifdef CONFIG_PGTABLE_MAPPING
|
2012-07-18 16:55:56 +00:00
|
|
|
static inline int __zs_cpu_up(struct mapping_area *area)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Make sure we don't leak memory if a cpu UP notification
|
|
|
|
* and zs_init() race and both call zs_cpu_up() on the same cpu
|
|
|
|
*/
|
|
|
|
if (area->vm)
|
|
|
|
return 0;
|
|
|
|
area->vm = alloc_vm_area(PAGE_SIZE * 2, NULL);
|
|
|
|
if (!area->vm)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void __zs_cpu_down(struct mapping_area *area)
|
|
|
|
{
|
|
|
|
if (area->vm)
|
|
|
|
free_vm_area(area->vm);
|
|
|
|
area->vm = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *__zs_map_object(struct mapping_area *area,
|
|
|
|
struct page *pages[2], int off, int size)
|
|
|
|
{
|
|
|
|
BUG_ON(map_vm_area(area->vm, PAGE_KERNEL, &pages));
|
|
|
|
area->vm_addr = area->vm->addr;
|
|
|
|
return area->vm_addr + off;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void __zs_unmap_object(struct mapping_area *area,
|
|
|
|
struct page *pages[2], int off, int size)
|
|
|
|
{
|
|
|
|
unsigned long addr = (unsigned long)area->vm_addr;
|
|
|
|
|
2013-03-27 00:43:14 +00:00
|
|
|
unmap_kernel_range(addr, PAGE_SIZE * 2);
|
2012-07-18 16:55:56 +00:00
|
|
|
}
|
|
|
|
|
2013-12-11 02:04:36 +00:00
|
|
|
#else /* CONFIG_PGTABLE_MAPPING */
|
2012-07-18 16:55:56 +00:00
|
|
|
|
|
|
|
static inline int __zs_cpu_up(struct mapping_area *area)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Make sure we don't leak memory if a cpu UP notification
|
|
|
|
* and zs_init() race and both call zs_cpu_up() on the same cpu
|
|
|
|
*/
|
|
|
|
if (area->vm_buf)
|
|
|
|
return 0;
|
2014-12-13 00:57:01 +00:00
|
|
|
area->vm_buf = kmalloc(ZS_MAX_ALLOC_SIZE, GFP_KERNEL);
|
2012-07-18 16:55:56 +00:00
|
|
|
if (!area->vm_buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void __zs_cpu_down(struct mapping_area *area)
|
|
|
|
{
|
2014-12-13 00:57:01 +00:00
|
|
|
kfree(area->vm_buf);
|
2012-07-18 16:55:56 +00:00
|
|
|
area->vm_buf = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *__zs_map_object(struct mapping_area *area,
|
|
|
|
struct page *pages[2], int off, int size)
|
2012-07-02 21:15:49 +00:00
|
|
|
{
|
|
|
|
int sizes[2];
|
|
|
|
void *addr;
|
2012-07-18 16:55:56 +00:00
|
|
|
char *buf = area->vm_buf;
|
2012-07-02 21:15:49 +00:00
|
|
|
|
2012-07-18 16:55:56 +00:00
|
|
|
/* disable page faults to match kmap_atomic() return conditions */
|
|
|
|
pagefault_disable();
|
|
|
|
|
|
|
|
/* no read fastpath */
|
|
|
|
if (area->vm_mm == ZS_MM_WO)
|
|
|
|
goto out;
|
2012-07-02 21:15:49 +00:00
|
|
|
|
|
|
|
sizes[0] = PAGE_SIZE - off;
|
|
|
|
sizes[1] = size - sizes[0];
|
|
|
|
|
|
|
|
/* copy object to per-cpu buffer */
|
|
|
|
addr = kmap_atomic(pages[0]);
|
|
|
|
memcpy(buf, addr + off, sizes[0]);
|
|
|
|
kunmap_atomic(addr);
|
|
|
|
addr = kmap_atomic(pages[1]);
|
|
|
|
memcpy(buf + sizes[0], addr, sizes[1]);
|
|
|
|
kunmap_atomic(addr);
|
2012-07-18 16:55:56 +00:00
|
|
|
out:
|
|
|
|
return area->vm_buf;
|
2012-07-02 21:15:49 +00:00
|
|
|
}
|
|
|
|
|
2012-07-18 16:55:56 +00:00
|
|
|
static void __zs_unmap_object(struct mapping_area *area,
|
|
|
|
struct page *pages[2], int off, int size)
|
2012-07-02 21:15:49 +00:00
|
|
|
{
|
|
|
|
int sizes[2];
|
|
|
|
void *addr;
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
char *buf;
|
2012-07-02 21:15:49 +00:00
|
|
|
|
2012-07-18 16:55:56 +00:00
|
|
|
/* no write fastpath */
|
|
|
|
if (area->vm_mm == ZS_MM_RO)
|
|
|
|
goto out;
|
2012-07-02 21:15:49 +00:00
|
|
|
|
2015-04-15 23:15:39 +00:00
|
|
|
buf = area->vm_buf;
|
|
|
|
if (!area->huge) {
|
|
|
|
buf = buf + ZS_HANDLE_SIZE;
|
|
|
|
size -= ZS_HANDLE_SIZE;
|
|
|
|
off += ZS_HANDLE_SIZE;
|
|
|
|
}
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
|
2012-07-02 21:15:49 +00:00
|
|
|
sizes[0] = PAGE_SIZE - off;
|
|
|
|
sizes[1] = size - sizes[0];
|
|
|
|
|
|
|
|
/* copy per-cpu buffer to object */
|
|
|
|
addr = kmap_atomic(pages[0]);
|
|
|
|
memcpy(addr + off, buf, sizes[0]);
|
|
|
|
kunmap_atomic(addr);
|
|
|
|
addr = kmap_atomic(pages[1]);
|
|
|
|
memcpy(addr, buf + sizes[0], sizes[1]);
|
|
|
|
kunmap_atomic(addr);
|
2012-07-18 16:55:56 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
/* enable page faults to match kunmap_atomic() return conditions */
|
|
|
|
pagefault_enable();
|
2012-07-02 21:15:49 +00:00
|
|
|
}
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2013-12-11 02:04:36 +00:00
|
|
|
#endif /* CONFIG_PGTABLE_MAPPING */
|
2012-07-18 16:55:56 +00:00
|
|
|
|
2012-01-09 22:51:56 +00:00
|
|
|
static int zs_cpu_notifier(struct notifier_block *nb, unsigned long action,
|
|
|
|
void *pcpu)
|
|
|
|
{
|
2012-07-18 16:55:56 +00:00
|
|
|
int ret, cpu = (long)pcpu;
|
2012-01-09 22:51:56 +00:00
|
|
|
struct mapping_area *area;
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case CPU_UP_PREPARE:
|
|
|
|
area = &per_cpu(zs_map_area, cpu);
|
2012-07-18 16:55:56 +00:00
|
|
|
ret = __zs_cpu_up(area);
|
|
|
|
if (ret)
|
|
|
|
return notifier_from_errno(ret);
|
2012-01-09 22:51:56 +00:00
|
|
|
break;
|
|
|
|
case CPU_DEAD:
|
|
|
|
case CPU_UP_CANCELED:
|
|
|
|
area = &per_cpu(zs_map_area, cpu);
|
2012-07-18 16:55:56 +00:00
|
|
|
__zs_cpu_down(area);
|
2012-01-09 22:51:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block zs_cpu_nb = {
|
|
|
|
.notifier_call = zs_cpu_notifier
|
|
|
|
};
|
|
|
|
|
2014-12-13 00:56:56 +00:00
|
|
|
static int zs_register_cpu_notifier(void)
|
2012-01-09 22:51:56 +00:00
|
|
|
{
|
2014-12-13 00:56:56 +00:00
|
|
|
int cpu, uninitialized_var(ret);
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-03-10 20:39:59 +00:00
|
|
|
cpu_notifier_register_begin();
|
|
|
|
|
|
|
|
__register_cpu_notifier(&zs_cpu_nb);
|
2012-01-09 22:51:56 +00:00
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
ret = zs_cpu_notifier(NULL, CPU_UP_PREPARE, (void *)(long)cpu);
|
2014-12-13 00:56:56 +00:00
|
|
|
if (notifier_to_errno(ret))
|
|
|
|
break;
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
2014-03-10 20:39:59 +00:00
|
|
|
|
|
|
|
cpu_notifier_register_done();
|
2014-12-13 00:56:56 +00:00
|
|
|
return notifier_to_errno(ret);
|
|
|
|
}
|
2014-03-10 20:39:59 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
static void zs_unregister_cpu_notifier(void)
|
2014-12-13 00:57:01 +00:00
|
|
|
{
|
2014-12-19 00:17:40 +00:00
|
|
|
int cpu;
|
2014-12-13 00:57:01 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
cpu_notifier_register_begin();
|
2014-12-13 00:57:01 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
for_each_online_cpu(cpu)
|
|
|
|
zs_cpu_notifier(NULL, CPU_DEAD, (void *)(long)cpu);
|
|
|
|
__unregister_cpu_notifier(&zs_cpu_nb);
|
2014-12-13 00:57:01 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
cpu_notifier_register_done();
|
2014-12-13 00:56:56 +00:00
|
|
|
}
|
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
static void init_zs_size_classes(void)
|
2014-12-13 00:56:56 +00:00
|
|
|
{
|
2014-12-19 00:17:40 +00:00
|
|
|
int nr;
|
2014-08-06 23:08:38 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
nr = (ZS_MAX_ALLOC_SIZE - ZS_MIN_ALLOC_SIZE) / ZS_SIZE_CLASS_DELTA + 1;
|
|
|
|
if ((ZS_MAX_ALLOC_SIZE - ZS_MIN_ALLOC_SIZE) % ZS_SIZE_CLASS_DELTA)
|
|
|
|
nr += 1;
|
2014-12-13 00:57:01 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
zs_size_classes = nr;
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
UPSTREAM: zsmalloc: merge size_class to reduce fragmentation
(cherry-pick from commit 9eec4cd53f9865b733dc78cf5f6465871beed014)
zsmalloc has many size_classes to reduce fragmentation and they are in 16
bytes unit, for example, 16, 32, 48, etc., if PAGE_SIZE is 4096. And,
zsmalloc has constraint that each zspage has 4 pages at maximum.
In this situation, we can see interesting aspect. Let's think about
size_class for 1488, 1472, ..., 1376. To prevent external fragmentation,
they uses 4 pages per zspage and so all they can contain 11 objects at
maximum.
16384 (4096 * 4) = 1488 * 11 + remains
16384 (4096 * 4) = 1472 * 11 + remains
16384 (4096 * 4) = ...
16384 (4096 * 4) = 1376 * 11 + remains
It means that they have same characteristics and classification between
them isn't needed. If we use one size_class for them, we can reduce
fragementation and save some memory since both the 1488 and 1472 sized
classes can only fit 11 objects into 4 pages, and an object that's 1472
bytes can fit into an object that's 1488 bytes, merging these classes to
always use objects that are 1488 bytes will reduce the total number of
size classes. And reducing the total number of size classes reduces
overall fragmentation, because a wider range of compressed pages can fit
into a single size class, leaving less unused objects in each size class.
For this purpose, this patch implement size_class merging. If there is
size_class that have same pages_per_zspage and same number of objects per
zspage with previous size_class, we don't create new size_class. Instead,
we use previous, same characteristic size_class. With this way, above
example sizes (1488, 1472, ..., 1376) use just one size_class so we can
get much more memory utilization.
Below is result of my simple test.
TEST ENV: EXT4 on zram, mount with discard option WORKLOAD: untar kernel
source code, remove directory in descending order in size. (drivers arch
fs sound include net Documentation firmware kernel tools)
Each line represents orig_data_size, compr_data_size, mem_used_total,
fragmentation overhead (mem_used - compr_data_size) and overhead ratio
(overhead to compr_data_size), respectively, after untar and remove
operation is executed.
* untar-nomerge.out
orig_size compr_size used_size overhead overhead_ratio
525.88MB 199.16MB 210.23MB 11.08MB 5.56%
288.32MB 97.43MB 105.63MB 8.20MB 8.41%
177.32MB 61.12MB 69.40MB 8.28MB 13.55%
146.47MB 47.32MB 56.10MB 8.78MB 18.55%
124.16MB 38.85MB 48.41MB 9.55MB 24.58%
103.93MB 31.68MB 40.93MB 9.25MB 29.21%
84.34MB 22.86MB 32.72MB 9.86MB 43.13%
66.87MB 14.83MB 23.83MB 9.00MB 60.70%
60.67MB 11.11MB 18.60MB 7.49MB 67.48%
55.86MB 8.83MB 16.61MB 7.77MB 88.03%
53.32MB 8.01MB 15.32MB 7.31MB 91.24%
* untar-merge.out
orig_size compr_size used_size overhead overhead_ratio
526.23MB 199.18MB 209.81MB 10.64MB 5.34%
288.68MB 97.45MB 104.08MB 6.63MB 6.80%
177.68MB 61.14MB 66.93MB 5.79MB 9.47%
146.83MB 47.34MB 52.79MB 5.45MB 11.51%
124.52MB 38.87MB 44.30MB 5.43MB 13.96%
104.29MB 31.70MB 36.83MB 5.13MB 16.19%
84.70MB 22.88MB 27.92MB 5.04MB 22.04%
67.11MB 14.83MB 19.26MB 4.43MB 29.86%
60.82MB 11.10MB 14.90MB 3.79MB 34.17%
55.90MB 8.82MB 12.61MB 3.79MB 42.97%
53.32MB 8.01MB 11.73MB 3.73MB 46.53%
As you can see above result, merged one has better utilization (overhead
ratio, 5th column) and uses less memory (mem_used_total, 3rd column).
Bug: 25951511
Change-Id: I00825d2b8de666abb7a0d8b47348b89e8af80571
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Reviewed-by: Dan Streetman <ddstreet@ieee.org>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: <juno.choi@lge.com>
Cc: "seungho1.park" <seungho1.park@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-12-13 00:56:44 +00:00
|
|
|
static bool can_merge(struct size_class *prev, int size, int pages_per_zspage)
|
|
|
|
{
|
|
|
|
if (prev->pages_per_zspage != pages_per_zspage)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (get_maxobj_per_zspage(prev->size, prev->pages_per_zspage)
|
|
|
|
!= get_maxobj_per_zspage(size, pages_per_zspage))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-04-15 23:15:30 +00:00
|
|
|
static bool zspage_full(struct page *page)
|
|
|
|
{
|
|
|
|
BUG_ON(!is_first_page(page));
|
|
|
|
|
|
|
|
return page->inuse == page->objects;
|
|
|
|
}
|
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
unsigned long zs_get_total_pages(struct zs_pool *pool)
|
|
|
|
{
|
|
|
|
return atomic_long_read(&pool->pages_allocated);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(zs_get_total_pages);
|
|
|
|
|
2013-01-04 20:14:00 +00:00
|
|
|
/**
|
2014-12-19 00:17:40 +00:00
|
|
|
* zs_map_object - get address of allocated object from handle.
|
|
|
|
* @pool: pool from which the object was allocated
|
|
|
|
* @handle: handle returned from zs_malloc
|
2013-01-04 20:14:00 +00:00
|
|
|
*
|
2014-12-19 00:17:40 +00:00
|
|
|
* Before using an object allocated from zs_malloc, it must be mapped using
|
|
|
|
* this function. When done with the object, it must be unmapped using
|
|
|
|
* zs_unmap_object.
|
2013-01-04 20:14:00 +00:00
|
|
|
*
|
2014-12-19 00:17:40 +00:00
|
|
|
* Only one object can be mapped per cpu at a time. There is no protection
|
|
|
|
* against nested mappings.
|
|
|
|
*
|
|
|
|
* This function returns with preemption and page faults disabled.
|
2013-01-04 20:14:00 +00:00
|
|
|
*/
|
2014-12-19 00:17:40 +00:00
|
|
|
void *zs_map_object(struct zs_pool *pool, unsigned long handle,
|
|
|
|
enum zs_mapmode mm)
|
2012-01-09 22:51:56 +00:00
|
|
|
{
|
2014-12-19 00:17:40 +00:00
|
|
|
struct page *page;
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
unsigned long obj, obj_idx, off;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
unsigned int class_idx;
|
|
|
|
enum fullness_group fg;
|
|
|
|
struct size_class *class;
|
|
|
|
struct mapping_area *area;
|
|
|
|
struct page *pages[2];
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
void *ret;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
BUG_ON(!handle);
|
2014-12-13 00:57:01 +00:00
|
|
|
|
UPSTREAM: zsmalloc: merge size_class to reduce fragmentation
(cherry-pick from commit 9eec4cd53f9865b733dc78cf5f6465871beed014)
zsmalloc has many size_classes to reduce fragmentation and they are in 16
bytes unit, for example, 16, 32, 48, etc., if PAGE_SIZE is 4096. And,
zsmalloc has constraint that each zspage has 4 pages at maximum.
In this situation, we can see interesting aspect. Let's think about
size_class for 1488, 1472, ..., 1376. To prevent external fragmentation,
they uses 4 pages per zspage and so all they can contain 11 objects at
maximum.
16384 (4096 * 4) = 1488 * 11 + remains
16384 (4096 * 4) = 1472 * 11 + remains
16384 (4096 * 4) = ...
16384 (4096 * 4) = 1376 * 11 + remains
It means that they have same characteristics and classification between
them isn't needed. If we use one size_class for them, we can reduce
fragementation and save some memory since both the 1488 and 1472 sized
classes can only fit 11 objects into 4 pages, and an object that's 1472
bytes can fit into an object that's 1488 bytes, merging these classes to
always use objects that are 1488 bytes will reduce the total number of
size classes. And reducing the total number of size classes reduces
overall fragmentation, because a wider range of compressed pages can fit
into a single size class, leaving less unused objects in each size class.
For this purpose, this patch implement size_class merging. If there is
size_class that have same pages_per_zspage and same number of objects per
zspage with previous size_class, we don't create new size_class. Instead,
we use previous, same characteristic size_class. With this way, above
example sizes (1488, 1472, ..., 1376) use just one size_class so we can
get much more memory utilization.
Below is result of my simple test.
TEST ENV: EXT4 on zram, mount with discard option WORKLOAD: untar kernel
source code, remove directory in descending order in size. (drivers arch
fs sound include net Documentation firmware kernel tools)
Each line represents orig_data_size, compr_data_size, mem_used_total,
fragmentation overhead (mem_used - compr_data_size) and overhead ratio
(overhead to compr_data_size), respectively, after untar and remove
operation is executed.
* untar-nomerge.out
orig_size compr_size used_size overhead overhead_ratio
525.88MB 199.16MB 210.23MB 11.08MB 5.56%
288.32MB 97.43MB 105.63MB 8.20MB 8.41%
177.32MB 61.12MB 69.40MB 8.28MB 13.55%
146.47MB 47.32MB 56.10MB 8.78MB 18.55%
124.16MB 38.85MB 48.41MB 9.55MB 24.58%
103.93MB 31.68MB 40.93MB 9.25MB 29.21%
84.34MB 22.86MB 32.72MB 9.86MB 43.13%
66.87MB 14.83MB 23.83MB 9.00MB 60.70%
60.67MB 11.11MB 18.60MB 7.49MB 67.48%
55.86MB 8.83MB 16.61MB 7.77MB 88.03%
53.32MB 8.01MB 15.32MB 7.31MB 91.24%
* untar-merge.out
orig_size compr_size used_size overhead overhead_ratio
526.23MB 199.18MB 209.81MB 10.64MB 5.34%
288.68MB 97.45MB 104.08MB 6.63MB 6.80%
177.68MB 61.14MB 66.93MB 5.79MB 9.47%
146.83MB 47.34MB 52.79MB 5.45MB 11.51%
124.52MB 38.87MB 44.30MB 5.43MB 13.96%
104.29MB 31.70MB 36.83MB 5.13MB 16.19%
84.70MB 22.88MB 27.92MB 5.04MB 22.04%
67.11MB 14.83MB 19.26MB 4.43MB 29.86%
60.82MB 11.10MB 14.90MB 3.79MB 34.17%
55.90MB 8.82MB 12.61MB 3.79MB 42.97%
53.32MB 8.01MB 11.73MB 3.73MB 46.53%
As you can see above result, merged one has better utilization (overhead
ratio, 5th column) and uses less memory (mem_used_total, 3rd column).
Bug: 25951511
Change-Id: I00825d2b8de666abb7a0d8b47348b89e8af80571
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Reviewed-by: Dan Streetman <ddstreet@ieee.org>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: <juno.choi@lge.com>
Cc: "seungho1.park" <seungho1.park@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-12-13 00:56:44 +00:00
|
|
|
/*
|
2014-12-19 00:17:40 +00:00
|
|
|
* Because we use per-cpu mapping areas shared among the
|
|
|
|
* pools/users, we can't allow mapping in interrupt context
|
|
|
|
* because it can corrupt another users mappings.
|
UPSTREAM: zsmalloc: merge size_class to reduce fragmentation
(cherry-pick from commit 9eec4cd53f9865b733dc78cf5f6465871beed014)
zsmalloc has many size_classes to reduce fragmentation and they are in 16
bytes unit, for example, 16, 32, 48, etc., if PAGE_SIZE is 4096. And,
zsmalloc has constraint that each zspage has 4 pages at maximum.
In this situation, we can see interesting aspect. Let's think about
size_class for 1488, 1472, ..., 1376. To prevent external fragmentation,
they uses 4 pages per zspage and so all they can contain 11 objects at
maximum.
16384 (4096 * 4) = 1488 * 11 + remains
16384 (4096 * 4) = 1472 * 11 + remains
16384 (4096 * 4) = ...
16384 (4096 * 4) = 1376 * 11 + remains
It means that they have same characteristics and classification between
them isn't needed. If we use one size_class for them, we can reduce
fragementation and save some memory since both the 1488 and 1472 sized
classes can only fit 11 objects into 4 pages, and an object that's 1472
bytes can fit into an object that's 1488 bytes, merging these classes to
always use objects that are 1488 bytes will reduce the total number of
size classes. And reducing the total number of size classes reduces
overall fragmentation, because a wider range of compressed pages can fit
into a single size class, leaving less unused objects in each size class.
For this purpose, this patch implement size_class merging. If there is
size_class that have same pages_per_zspage and same number of objects per
zspage with previous size_class, we don't create new size_class. Instead,
we use previous, same characteristic size_class. With this way, above
example sizes (1488, 1472, ..., 1376) use just one size_class so we can
get much more memory utilization.
Below is result of my simple test.
TEST ENV: EXT4 on zram, mount with discard option WORKLOAD: untar kernel
source code, remove directory in descending order in size. (drivers arch
fs sound include net Documentation firmware kernel tools)
Each line represents orig_data_size, compr_data_size, mem_used_total,
fragmentation overhead (mem_used - compr_data_size) and overhead ratio
(overhead to compr_data_size), respectively, after untar and remove
operation is executed.
* untar-nomerge.out
orig_size compr_size used_size overhead overhead_ratio
525.88MB 199.16MB 210.23MB 11.08MB 5.56%
288.32MB 97.43MB 105.63MB 8.20MB 8.41%
177.32MB 61.12MB 69.40MB 8.28MB 13.55%
146.47MB 47.32MB 56.10MB 8.78MB 18.55%
124.16MB 38.85MB 48.41MB 9.55MB 24.58%
103.93MB 31.68MB 40.93MB 9.25MB 29.21%
84.34MB 22.86MB 32.72MB 9.86MB 43.13%
66.87MB 14.83MB 23.83MB 9.00MB 60.70%
60.67MB 11.11MB 18.60MB 7.49MB 67.48%
55.86MB 8.83MB 16.61MB 7.77MB 88.03%
53.32MB 8.01MB 15.32MB 7.31MB 91.24%
* untar-merge.out
orig_size compr_size used_size overhead overhead_ratio
526.23MB 199.18MB 209.81MB 10.64MB 5.34%
288.68MB 97.45MB 104.08MB 6.63MB 6.80%
177.68MB 61.14MB 66.93MB 5.79MB 9.47%
146.83MB 47.34MB 52.79MB 5.45MB 11.51%
124.52MB 38.87MB 44.30MB 5.43MB 13.96%
104.29MB 31.70MB 36.83MB 5.13MB 16.19%
84.70MB 22.88MB 27.92MB 5.04MB 22.04%
67.11MB 14.83MB 19.26MB 4.43MB 29.86%
60.82MB 11.10MB 14.90MB 3.79MB 34.17%
55.90MB 8.82MB 12.61MB 3.79MB 42.97%
53.32MB 8.01MB 11.73MB 3.73MB 46.53%
As you can see above result, merged one has better utilization (overhead
ratio, 5th column) and uses less memory (mem_used_total, 3rd column).
Bug: 25951511
Change-Id: I00825d2b8de666abb7a0d8b47348b89e8af80571
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Reviewed-by: Dan Streetman <ddstreet@ieee.org>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: <juno.choi@lge.com>
Cc: "seungho1.park" <seungho1.park@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-12-13 00:56:44 +00:00
|
|
|
*/
|
2014-12-19 00:17:40 +00:00
|
|
|
BUG_ON(in_interrupt());
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2015-04-15 23:15:30 +00:00
|
|
|
/* From now on, migration cannot move the object */
|
|
|
|
pin_tag(handle);
|
|
|
|
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
obj = handle_to_obj(handle);
|
|
|
|
obj_to_location(obj, &page, &obj_idx);
|
2014-12-19 00:17:40 +00:00
|
|
|
get_zspage_mapping(get_first_page(page), &class_idx, &fg);
|
|
|
|
class = pool->size_class[class_idx];
|
|
|
|
off = obj_idx_to_offset(page, obj_idx, class->size);
|
2014-12-13 00:57:07 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
area = &get_cpu_var(zs_map_area);
|
|
|
|
area->vm_mm = mm;
|
|
|
|
if (off + class->size <= PAGE_SIZE) {
|
|
|
|
/* this object is contained entirely within a page */
|
|
|
|
area->vm_addr = kmap_atomic(page);
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
ret = area->vm_addr + off;
|
|
|
|
goto out;
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
/* this object spans two pages */
|
|
|
|
pages[0] = page;
|
|
|
|
pages[1] = get_next_page(page);
|
|
|
|
BUG_ON(!pages[1]);
|
UPSTREAM: zsmalloc: merge size_class to reduce fragmentation
(cherry-pick from commit 9eec4cd53f9865b733dc78cf5f6465871beed014)
zsmalloc has many size_classes to reduce fragmentation and they are in 16
bytes unit, for example, 16, 32, 48, etc., if PAGE_SIZE is 4096. And,
zsmalloc has constraint that each zspage has 4 pages at maximum.
In this situation, we can see interesting aspect. Let's think about
size_class for 1488, 1472, ..., 1376. To prevent external fragmentation,
they uses 4 pages per zspage and so all they can contain 11 objects at
maximum.
16384 (4096 * 4) = 1488 * 11 + remains
16384 (4096 * 4) = 1472 * 11 + remains
16384 (4096 * 4) = ...
16384 (4096 * 4) = 1376 * 11 + remains
It means that they have same characteristics and classification between
them isn't needed. If we use one size_class for them, we can reduce
fragementation and save some memory since both the 1488 and 1472 sized
classes can only fit 11 objects into 4 pages, and an object that's 1472
bytes can fit into an object that's 1488 bytes, merging these classes to
always use objects that are 1488 bytes will reduce the total number of
size classes. And reducing the total number of size classes reduces
overall fragmentation, because a wider range of compressed pages can fit
into a single size class, leaving less unused objects in each size class.
For this purpose, this patch implement size_class merging. If there is
size_class that have same pages_per_zspage and same number of objects per
zspage with previous size_class, we don't create new size_class. Instead,
we use previous, same characteristic size_class. With this way, above
example sizes (1488, 1472, ..., 1376) use just one size_class so we can
get much more memory utilization.
Below is result of my simple test.
TEST ENV: EXT4 on zram, mount with discard option WORKLOAD: untar kernel
source code, remove directory in descending order in size. (drivers arch
fs sound include net Documentation firmware kernel tools)
Each line represents orig_data_size, compr_data_size, mem_used_total,
fragmentation overhead (mem_used - compr_data_size) and overhead ratio
(overhead to compr_data_size), respectively, after untar and remove
operation is executed.
* untar-nomerge.out
orig_size compr_size used_size overhead overhead_ratio
525.88MB 199.16MB 210.23MB 11.08MB 5.56%
288.32MB 97.43MB 105.63MB 8.20MB 8.41%
177.32MB 61.12MB 69.40MB 8.28MB 13.55%
146.47MB 47.32MB 56.10MB 8.78MB 18.55%
124.16MB 38.85MB 48.41MB 9.55MB 24.58%
103.93MB 31.68MB 40.93MB 9.25MB 29.21%
84.34MB 22.86MB 32.72MB 9.86MB 43.13%
66.87MB 14.83MB 23.83MB 9.00MB 60.70%
60.67MB 11.11MB 18.60MB 7.49MB 67.48%
55.86MB 8.83MB 16.61MB 7.77MB 88.03%
53.32MB 8.01MB 15.32MB 7.31MB 91.24%
* untar-merge.out
orig_size compr_size used_size overhead overhead_ratio
526.23MB 199.18MB 209.81MB 10.64MB 5.34%
288.68MB 97.45MB 104.08MB 6.63MB 6.80%
177.68MB 61.14MB 66.93MB 5.79MB 9.47%
146.83MB 47.34MB 52.79MB 5.45MB 11.51%
124.52MB 38.87MB 44.30MB 5.43MB 13.96%
104.29MB 31.70MB 36.83MB 5.13MB 16.19%
84.70MB 22.88MB 27.92MB 5.04MB 22.04%
67.11MB 14.83MB 19.26MB 4.43MB 29.86%
60.82MB 11.10MB 14.90MB 3.79MB 34.17%
55.90MB 8.82MB 12.61MB 3.79MB 42.97%
53.32MB 8.01MB 11.73MB 3.73MB 46.53%
As you can see above result, merged one has better utilization (overhead
ratio, 5th column) and uses less memory (mem_used_total, 3rd column).
Bug: 25951511
Change-Id: I00825d2b8de666abb7a0d8b47348b89e8af80571
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Reviewed-by: Dan Streetman <ddstreet@ieee.org>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: <juno.choi@lge.com>
Cc: "seungho1.park" <seungho1.park@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-12-13 00:56:44 +00:00
|
|
|
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
ret = __zs_map_object(area, pages, off, class->size);
|
|
|
|
out:
|
2015-04-15 23:15:39 +00:00
|
|
|
if (!class->huge)
|
|
|
|
ret += ZS_HANDLE_SIZE;
|
|
|
|
|
|
|
|
return ret;
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
2014-12-19 00:17:40 +00:00
|
|
|
EXPORT_SYMBOL_GPL(zs_map_object);
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
void zs_unmap_object(struct zs_pool *pool, unsigned long handle)
|
2012-01-09 22:51:56 +00:00
|
|
|
{
|
2014-12-19 00:17:40 +00:00
|
|
|
struct page *page;
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
unsigned long obj, obj_idx, off;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
unsigned int class_idx;
|
|
|
|
enum fullness_group fg;
|
|
|
|
struct size_class *class;
|
|
|
|
struct mapping_area *area;
|
UPSTREAM: zsmalloc: merge size_class to reduce fragmentation
(cherry-pick from commit 9eec4cd53f9865b733dc78cf5f6465871beed014)
zsmalloc has many size_classes to reduce fragmentation and they are in 16
bytes unit, for example, 16, 32, 48, etc., if PAGE_SIZE is 4096. And,
zsmalloc has constraint that each zspage has 4 pages at maximum.
In this situation, we can see interesting aspect. Let's think about
size_class for 1488, 1472, ..., 1376. To prevent external fragmentation,
they uses 4 pages per zspage and so all they can contain 11 objects at
maximum.
16384 (4096 * 4) = 1488 * 11 + remains
16384 (4096 * 4) = 1472 * 11 + remains
16384 (4096 * 4) = ...
16384 (4096 * 4) = 1376 * 11 + remains
It means that they have same characteristics and classification between
them isn't needed. If we use one size_class for them, we can reduce
fragementation and save some memory since both the 1488 and 1472 sized
classes can only fit 11 objects into 4 pages, and an object that's 1472
bytes can fit into an object that's 1488 bytes, merging these classes to
always use objects that are 1488 bytes will reduce the total number of
size classes. And reducing the total number of size classes reduces
overall fragmentation, because a wider range of compressed pages can fit
into a single size class, leaving less unused objects in each size class.
For this purpose, this patch implement size_class merging. If there is
size_class that have same pages_per_zspage and same number of objects per
zspage with previous size_class, we don't create new size_class. Instead,
we use previous, same characteristic size_class. With this way, above
example sizes (1488, 1472, ..., 1376) use just one size_class so we can
get much more memory utilization.
Below is result of my simple test.
TEST ENV: EXT4 on zram, mount with discard option WORKLOAD: untar kernel
source code, remove directory in descending order in size. (drivers arch
fs sound include net Documentation firmware kernel tools)
Each line represents orig_data_size, compr_data_size, mem_used_total,
fragmentation overhead (mem_used - compr_data_size) and overhead ratio
(overhead to compr_data_size), respectively, after untar and remove
operation is executed.
* untar-nomerge.out
orig_size compr_size used_size overhead overhead_ratio
525.88MB 199.16MB 210.23MB 11.08MB 5.56%
288.32MB 97.43MB 105.63MB 8.20MB 8.41%
177.32MB 61.12MB 69.40MB 8.28MB 13.55%
146.47MB 47.32MB 56.10MB 8.78MB 18.55%
124.16MB 38.85MB 48.41MB 9.55MB 24.58%
103.93MB 31.68MB 40.93MB 9.25MB 29.21%
84.34MB 22.86MB 32.72MB 9.86MB 43.13%
66.87MB 14.83MB 23.83MB 9.00MB 60.70%
60.67MB 11.11MB 18.60MB 7.49MB 67.48%
55.86MB 8.83MB 16.61MB 7.77MB 88.03%
53.32MB 8.01MB 15.32MB 7.31MB 91.24%
* untar-merge.out
orig_size compr_size used_size overhead overhead_ratio
526.23MB 199.18MB 209.81MB 10.64MB 5.34%
288.68MB 97.45MB 104.08MB 6.63MB 6.80%
177.68MB 61.14MB 66.93MB 5.79MB 9.47%
146.83MB 47.34MB 52.79MB 5.45MB 11.51%
124.52MB 38.87MB 44.30MB 5.43MB 13.96%
104.29MB 31.70MB 36.83MB 5.13MB 16.19%
84.70MB 22.88MB 27.92MB 5.04MB 22.04%
67.11MB 14.83MB 19.26MB 4.43MB 29.86%
60.82MB 11.10MB 14.90MB 3.79MB 34.17%
55.90MB 8.82MB 12.61MB 3.79MB 42.97%
53.32MB 8.01MB 11.73MB 3.73MB 46.53%
As you can see above result, merged one has better utilization (overhead
ratio, 5th column) and uses less memory (mem_used_total, 3rd column).
Bug: 25951511
Change-Id: I00825d2b8de666abb7a0d8b47348b89e8af80571
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Reviewed-by: Dan Streetman <ddstreet@ieee.org>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: <juno.choi@lge.com>
Cc: "seungho1.park" <seungho1.park@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-12-13 00:56:44 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
BUG_ON(!handle);
|
UPSTREAM: zsmalloc: merge size_class to reduce fragmentation
(cherry-pick from commit 9eec4cd53f9865b733dc78cf5f6465871beed014)
zsmalloc has many size_classes to reduce fragmentation and they are in 16
bytes unit, for example, 16, 32, 48, etc., if PAGE_SIZE is 4096. And,
zsmalloc has constraint that each zspage has 4 pages at maximum.
In this situation, we can see interesting aspect. Let's think about
size_class for 1488, 1472, ..., 1376. To prevent external fragmentation,
they uses 4 pages per zspage and so all they can contain 11 objects at
maximum.
16384 (4096 * 4) = 1488 * 11 + remains
16384 (4096 * 4) = 1472 * 11 + remains
16384 (4096 * 4) = ...
16384 (4096 * 4) = 1376 * 11 + remains
It means that they have same characteristics and classification between
them isn't needed. If we use one size_class for them, we can reduce
fragementation and save some memory since both the 1488 and 1472 sized
classes can only fit 11 objects into 4 pages, and an object that's 1472
bytes can fit into an object that's 1488 bytes, merging these classes to
always use objects that are 1488 bytes will reduce the total number of
size classes. And reducing the total number of size classes reduces
overall fragmentation, because a wider range of compressed pages can fit
into a single size class, leaving less unused objects in each size class.
For this purpose, this patch implement size_class merging. If there is
size_class that have same pages_per_zspage and same number of objects per
zspage with previous size_class, we don't create new size_class. Instead,
we use previous, same characteristic size_class. With this way, above
example sizes (1488, 1472, ..., 1376) use just one size_class so we can
get much more memory utilization.
Below is result of my simple test.
TEST ENV: EXT4 on zram, mount with discard option WORKLOAD: untar kernel
source code, remove directory in descending order in size. (drivers arch
fs sound include net Documentation firmware kernel tools)
Each line represents orig_data_size, compr_data_size, mem_used_total,
fragmentation overhead (mem_used - compr_data_size) and overhead ratio
(overhead to compr_data_size), respectively, after untar and remove
operation is executed.
* untar-nomerge.out
orig_size compr_size used_size overhead overhead_ratio
525.88MB 199.16MB 210.23MB 11.08MB 5.56%
288.32MB 97.43MB 105.63MB 8.20MB 8.41%
177.32MB 61.12MB 69.40MB 8.28MB 13.55%
146.47MB 47.32MB 56.10MB 8.78MB 18.55%
124.16MB 38.85MB 48.41MB 9.55MB 24.58%
103.93MB 31.68MB 40.93MB 9.25MB 29.21%
84.34MB 22.86MB 32.72MB 9.86MB 43.13%
66.87MB 14.83MB 23.83MB 9.00MB 60.70%
60.67MB 11.11MB 18.60MB 7.49MB 67.48%
55.86MB 8.83MB 16.61MB 7.77MB 88.03%
53.32MB 8.01MB 15.32MB 7.31MB 91.24%
* untar-merge.out
orig_size compr_size used_size overhead overhead_ratio
526.23MB 199.18MB 209.81MB 10.64MB 5.34%
288.68MB 97.45MB 104.08MB 6.63MB 6.80%
177.68MB 61.14MB 66.93MB 5.79MB 9.47%
146.83MB 47.34MB 52.79MB 5.45MB 11.51%
124.52MB 38.87MB 44.30MB 5.43MB 13.96%
104.29MB 31.70MB 36.83MB 5.13MB 16.19%
84.70MB 22.88MB 27.92MB 5.04MB 22.04%
67.11MB 14.83MB 19.26MB 4.43MB 29.86%
60.82MB 11.10MB 14.90MB 3.79MB 34.17%
55.90MB 8.82MB 12.61MB 3.79MB 42.97%
53.32MB 8.01MB 11.73MB 3.73MB 46.53%
As you can see above result, merged one has better utilization (overhead
ratio, 5th column) and uses less memory (mem_used_total, 3rd column).
Bug: 25951511
Change-Id: I00825d2b8de666abb7a0d8b47348b89e8af80571
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Reviewed-by: Dan Streetman <ddstreet@ieee.org>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: <juno.choi@lge.com>
Cc: "seungho1.park" <seungho1.park@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-12-13 00:56:44 +00:00
|
|
|
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
obj = handle_to_obj(handle);
|
|
|
|
obj_to_location(obj, &page, &obj_idx);
|
2014-12-19 00:17:40 +00:00
|
|
|
get_zspage_mapping(get_first_page(page), &class_idx, &fg);
|
|
|
|
class = pool->size_class[class_idx];
|
|
|
|
off = obj_idx_to_offset(page, obj_idx, class->size);
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
area = this_cpu_ptr(&zs_map_area);
|
|
|
|
if (off + class->size <= PAGE_SIZE)
|
|
|
|
kunmap_atomic(area->vm_addr);
|
|
|
|
else {
|
|
|
|
struct page *pages[2];
|
2014-12-13 00:57:01 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
pages[0] = page;
|
|
|
|
pages[1] = get_next_page(page);
|
|
|
|
BUG_ON(!pages[1]);
|
|
|
|
|
|
|
|
__zs_unmap_object(area, pages, off, class->size);
|
|
|
|
}
|
|
|
|
put_cpu_var(zs_map_area);
|
2015-04-15 23:15:30 +00:00
|
|
|
unpin_tag(handle);
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
2014-12-19 00:17:40 +00:00
|
|
|
EXPORT_SYMBOL_GPL(zs_unmap_object);
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2015-04-15 23:15:26 +00:00
|
|
|
static unsigned long obj_malloc(struct page *first_page,
|
|
|
|
struct size_class *class, unsigned long handle)
|
|
|
|
{
|
|
|
|
unsigned long obj;
|
|
|
|
struct link_free *link;
|
|
|
|
|
|
|
|
struct page *m_page;
|
|
|
|
unsigned long m_objidx, m_offset;
|
|
|
|
void *vaddr;
|
|
|
|
|
2015-04-15 23:15:30 +00:00
|
|
|
handle |= OBJ_ALLOCATED_TAG;
|
2015-04-15 23:15:26 +00:00
|
|
|
obj = (unsigned long)first_page->freelist;
|
|
|
|
obj_to_location(obj, &m_page, &m_objidx);
|
|
|
|
m_offset = obj_idx_to_offset(m_page, m_objidx, class->size);
|
|
|
|
|
|
|
|
vaddr = kmap_atomic(m_page);
|
|
|
|
link = (struct link_free *)vaddr + m_offset / sizeof(*link);
|
|
|
|
first_page->freelist = link->next;
|
2015-04-15 23:15:39 +00:00
|
|
|
if (!class->huge)
|
|
|
|
/* record handle in the header of allocated chunk */
|
|
|
|
link->handle = handle;
|
|
|
|
else
|
|
|
|
/* record handle in first_page->private */
|
|
|
|
set_page_private(first_page, handle);
|
2015-04-15 23:15:26 +00:00
|
|
|
kunmap_atomic(vaddr);
|
|
|
|
first_page->inuse++;
|
|
|
|
zs_stat_inc(class, OBJ_USED, 1);
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-01-09 22:51:56 +00:00
|
|
|
/**
|
|
|
|
* zs_malloc - Allocate block of given size from pool.
|
|
|
|
* @pool: pool to allocate from
|
|
|
|
* @size: size of block to allocate
|
|
|
|
*
|
2012-05-03 06:40:40 +00:00
|
|
|
* On success, handle to the allocated object is returned,
|
2012-06-08 06:39:25 +00:00
|
|
|
* otherwise 0.
|
2012-01-09 22:51:56 +00:00
|
|
|
* Allocation requests with size > ZS_MAX_ALLOC_SIZE will fail.
|
|
|
|
*/
|
2012-06-08 06:39:25 +00:00
|
|
|
unsigned long zs_malloc(struct zs_pool *pool, size_t size)
|
2012-01-09 22:51:56 +00:00
|
|
|
{
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
unsigned long handle, obj;
|
2012-01-09 22:51:56 +00:00
|
|
|
struct size_class *class;
|
2015-04-15 23:15:26 +00:00
|
|
|
struct page *first_page;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2015-04-15 23:15:39 +00:00
|
|
|
if (unlikely(!size || size > ZS_MAX_ALLOC_SIZE))
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
handle = alloc_handle(pool);
|
|
|
|
if (!handle)
|
2012-06-08 06:39:25 +00:00
|
|
|
return 0;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
/* extra space in chunk to keep the handle */
|
|
|
|
size += ZS_HANDLE_SIZE;
|
UPSTREAM: zsmalloc: merge size_class to reduce fragmentation
(cherry-pick from commit 9eec4cd53f9865b733dc78cf5f6465871beed014)
zsmalloc has many size_classes to reduce fragmentation and they are in 16
bytes unit, for example, 16, 32, 48, etc., if PAGE_SIZE is 4096. And,
zsmalloc has constraint that each zspage has 4 pages at maximum.
In this situation, we can see interesting aspect. Let's think about
size_class for 1488, 1472, ..., 1376. To prevent external fragmentation,
they uses 4 pages per zspage and so all they can contain 11 objects at
maximum.
16384 (4096 * 4) = 1488 * 11 + remains
16384 (4096 * 4) = 1472 * 11 + remains
16384 (4096 * 4) = ...
16384 (4096 * 4) = 1376 * 11 + remains
It means that they have same characteristics and classification between
them isn't needed. If we use one size_class for them, we can reduce
fragementation and save some memory since both the 1488 and 1472 sized
classes can only fit 11 objects into 4 pages, and an object that's 1472
bytes can fit into an object that's 1488 bytes, merging these classes to
always use objects that are 1488 bytes will reduce the total number of
size classes. And reducing the total number of size classes reduces
overall fragmentation, because a wider range of compressed pages can fit
into a single size class, leaving less unused objects in each size class.
For this purpose, this patch implement size_class merging. If there is
size_class that have same pages_per_zspage and same number of objects per
zspage with previous size_class, we don't create new size_class. Instead,
we use previous, same characteristic size_class. With this way, above
example sizes (1488, 1472, ..., 1376) use just one size_class so we can
get much more memory utilization.
Below is result of my simple test.
TEST ENV: EXT4 on zram, mount with discard option WORKLOAD: untar kernel
source code, remove directory in descending order in size. (drivers arch
fs sound include net Documentation firmware kernel tools)
Each line represents orig_data_size, compr_data_size, mem_used_total,
fragmentation overhead (mem_used - compr_data_size) and overhead ratio
(overhead to compr_data_size), respectively, after untar and remove
operation is executed.
* untar-nomerge.out
orig_size compr_size used_size overhead overhead_ratio
525.88MB 199.16MB 210.23MB 11.08MB 5.56%
288.32MB 97.43MB 105.63MB 8.20MB 8.41%
177.32MB 61.12MB 69.40MB 8.28MB 13.55%
146.47MB 47.32MB 56.10MB 8.78MB 18.55%
124.16MB 38.85MB 48.41MB 9.55MB 24.58%
103.93MB 31.68MB 40.93MB 9.25MB 29.21%
84.34MB 22.86MB 32.72MB 9.86MB 43.13%
66.87MB 14.83MB 23.83MB 9.00MB 60.70%
60.67MB 11.11MB 18.60MB 7.49MB 67.48%
55.86MB 8.83MB 16.61MB 7.77MB 88.03%
53.32MB 8.01MB 15.32MB 7.31MB 91.24%
* untar-merge.out
orig_size compr_size used_size overhead overhead_ratio
526.23MB 199.18MB 209.81MB 10.64MB 5.34%
288.68MB 97.45MB 104.08MB 6.63MB 6.80%
177.68MB 61.14MB 66.93MB 5.79MB 9.47%
146.83MB 47.34MB 52.79MB 5.45MB 11.51%
124.52MB 38.87MB 44.30MB 5.43MB 13.96%
104.29MB 31.70MB 36.83MB 5.13MB 16.19%
84.70MB 22.88MB 27.92MB 5.04MB 22.04%
67.11MB 14.83MB 19.26MB 4.43MB 29.86%
60.82MB 11.10MB 14.90MB 3.79MB 34.17%
55.90MB 8.82MB 12.61MB 3.79MB 42.97%
53.32MB 8.01MB 11.73MB 3.73MB 46.53%
As you can see above result, merged one has better utilization (overhead
ratio, 5th column) and uses less memory (mem_used_total, 3rd column).
Bug: 25951511
Change-Id: I00825d2b8de666abb7a0d8b47348b89e8af80571
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Reviewed-by: Dan Streetman <ddstreet@ieee.org>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: <juno.choi@lge.com>
Cc: "seungho1.park" <seungho1.park@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-12-13 00:56:44 +00:00
|
|
|
class = pool->size_class[get_size_class_index(size)];
|
2015-04-15 23:15:39 +00:00
|
|
|
/* In huge class size, we store the handle into first_page->private */
|
|
|
|
if (class->huge) {
|
|
|
|
size -= ZS_HANDLE_SIZE;
|
|
|
|
class = pool->size_class[get_size_class_index(size)];
|
|
|
|
}
|
2012-01-09 22:51:56 +00:00
|
|
|
|
|
|
|
spin_lock(&class->lock);
|
|
|
|
first_page = find_get_zspage(class);
|
|
|
|
|
|
|
|
if (!first_page) {
|
|
|
|
spin_unlock(&class->lock);
|
|
|
|
first_page = alloc_zspage(class, pool->flags);
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
if (unlikely(!first_page)) {
|
|
|
|
free_handle(pool, handle);
|
2012-06-08 06:39:25 +00:00
|
|
|
return 0;
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
}
|
2012-01-09 22:51:56 +00:00
|
|
|
|
|
|
|
set_zspage_mapping(first_page, class->index, ZS_EMPTY);
|
UPSTREAM: zsmalloc: move pages_allocated to zs_pool
(cherry-pick from commit 13de8933c96b4557f667c337676f05274e017f83)
Currently, zram has no feature to limit memory so theoretically zram can
deplete system memory. Users have asked for a limit several times as even
without exhaustion zram makes it hard to control memory usage of the
platform. This patchset adds the feature.
Patch 1 makes zs_get_total_size_bytes faster because it would be used
frequently in later patches for the new feature.
Patch 2 changes zs_get_total_size_bytes's return unit from bytes to page
so that zsmalloc doesn't need unnecessary operation(ie, << PAGE_SHIFT).
Patch 3 adds new feature. I added the feature into zram layer, not
zsmalloc because limiation is zram's requirement, not zsmalloc so any
other user using zsmalloc(ie, zpool) shouldn't affected by unnecessary
branch of zsmalloc. In future, if every users of zsmalloc want the
feature, then, we could move the feature from client side to zsmalloc
easily but vice versa would be painful.
Patch 4 adds news facility to report maximum memory usage of zram so that
this avoids user polling frequently via /sys/block/zram0/ mem_used_total
and ensures transient max are not missed.
This patch (of 4):
pages_allocated has counted in size_class structure and when user of
zsmalloc want to see total_size_bytes, it should gather all of count from
each size_class to report the sum.
It's not bad if user don't see the value often but if user start to see
the value frequently, it would be not a good deal for performance pov.
This patch moves the count from size_class to zs_pool so it could reduce
memory footprint (from [255 * 8byte] to [sizeof(atomic_long_t)]).
Bug: 25951511
Change-Id: I05526575b81c95a12a7f8f0ef05040ed18b5fa6f
Signed-off-by: Minchan Kim <minchan@kernel.org>
Reviewed-by: Dan Streetman <ddstreet@ieee.org>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: <juno.choi@lge.com>
Cc: <seungho1.park@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Reviewed-by: David Horner <ds2horner@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-10-09 22:29:48 +00:00
|
|
|
atomic_long_add(class->pages_per_zspage,
|
|
|
|
&pool->pages_allocated);
|
2015-02-12 23:00:54 +00:00
|
|
|
|
2012-01-09 22:51:56 +00:00
|
|
|
spin_lock(&class->lock);
|
2015-02-12 23:00:54 +00:00
|
|
|
zs_stat_inc(class, OBJ_ALLOCATED, get_maxobj_per_zspage(
|
|
|
|
class->size, class->pages_per_zspage));
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
2015-04-15 23:15:26 +00:00
|
|
|
obj = obj_malloc(first_page, class, handle);
|
2012-01-09 22:51:56 +00:00
|
|
|
/* Now move the zspage to another fullness group, if required */
|
2015-04-15 23:15:26 +00:00
|
|
|
fix_fullness_group(class, first_page);
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
record_obj(handle, obj);
|
2012-01-09 22:51:56 +00:00
|
|
|
spin_unlock(&class->lock);
|
|
|
|
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
return handle;
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(zs_malloc);
|
|
|
|
|
2015-04-15 23:15:26 +00:00
|
|
|
static void obj_free(struct zs_pool *pool, struct size_class *class,
|
|
|
|
unsigned long obj)
|
2012-01-09 22:51:56 +00:00
|
|
|
{
|
|
|
|
struct link_free *link;
|
|
|
|
struct page *first_page, *f_page;
|
2015-04-15 23:15:26 +00:00
|
|
|
unsigned long f_objidx, f_offset;
|
2014-12-13 00:56:58 +00:00
|
|
|
void *vaddr;
|
2012-01-09 22:51:56 +00:00
|
|
|
int class_idx;
|
|
|
|
enum fullness_group fullness;
|
|
|
|
|
2015-04-15 23:15:26 +00:00
|
|
|
BUG_ON(!obj);
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2015-04-15 23:15:30 +00:00
|
|
|
obj &= ~OBJ_ALLOCATED_TAG;
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
obj_to_location(obj, &f_page, &f_objidx);
|
2012-01-09 22:51:56 +00:00
|
|
|
first_page = get_first_page(f_page);
|
|
|
|
|
|
|
|
get_zspage_mapping(first_page, &class_idx, &fullness);
|
|
|
|
f_offset = obj_idx_to_offset(f_page, f_objidx, class->size);
|
|
|
|
|
2015-04-15 23:15:26 +00:00
|
|
|
vaddr = kmap_atomic(f_page);
|
2012-01-09 22:51:56 +00:00
|
|
|
|
|
|
|
/* Insert this object in containing zspage's freelist */
|
2014-12-13 00:56:58 +00:00
|
|
|
link = (struct link_free *)(vaddr + f_offset);
|
2012-01-09 22:51:56 +00:00
|
|
|
link->next = first_page->freelist;
|
2015-04-15 23:15:39 +00:00
|
|
|
if (class->huge)
|
|
|
|
set_page_private(first_page, 0);
|
2014-12-13 00:56:58 +00:00
|
|
|
kunmap_atomic(vaddr);
|
2012-06-08 06:39:25 +00:00
|
|
|
first_page->freelist = (void *)obj;
|
2012-01-09 22:51:56 +00:00
|
|
|
first_page->inuse--;
|
2015-02-12 23:00:54 +00:00
|
|
|
zs_stat_dec(class, OBJ_USED, 1);
|
2015-04-15 23:15:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void zs_free(struct zs_pool *pool, unsigned long handle)
|
|
|
|
{
|
|
|
|
struct page *first_page, *f_page;
|
|
|
|
unsigned long obj, f_objidx;
|
|
|
|
int class_idx;
|
|
|
|
struct size_class *class;
|
|
|
|
enum fullness_group fullness;
|
|
|
|
|
|
|
|
if (unlikely(!handle))
|
|
|
|
return;
|
|
|
|
|
2015-04-15 23:15:30 +00:00
|
|
|
pin_tag(handle);
|
2015-04-15 23:15:26 +00:00
|
|
|
obj = handle_to_obj(handle);
|
|
|
|
obj_to_location(obj, &f_page, &f_objidx);
|
|
|
|
first_page = get_first_page(f_page);
|
|
|
|
|
|
|
|
get_zspage_mapping(first_page, &class_idx, &fullness);
|
|
|
|
class = pool->size_class[class_idx];
|
|
|
|
|
|
|
|
spin_lock(&class->lock);
|
|
|
|
obj_free(pool, class, obj);
|
|
|
|
fullness = fix_fullness_group(class, first_page);
|
2015-04-15 23:15:30 +00:00
|
|
|
if (fullness == ZS_EMPTY) {
|
2015-02-12 23:00:54 +00:00
|
|
|
zs_stat_dec(class, OBJ_ALLOCATED, get_maxobj_per_zspage(
|
|
|
|
class->size, class->pages_per_zspage));
|
2015-04-15 23:15:30 +00:00
|
|
|
atomic_long_sub(class->pages_per_zspage,
|
|
|
|
&pool->pages_allocated);
|
|
|
|
free_zspage(first_page);
|
|
|
|
}
|
2012-01-09 22:51:56 +00:00
|
|
|
spin_unlock(&class->lock);
|
2015-04-15 23:15:30 +00:00
|
|
|
unpin_tag(handle);
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2015-04-15 23:15:30 +00:00
|
|
|
free_handle(pool, handle);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(zs_free);
|
|
|
|
|
|
|
|
static void zs_object_copy(unsigned long src, unsigned long dst,
|
|
|
|
struct size_class *class)
|
|
|
|
{
|
|
|
|
struct page *s_page, *d_page;
|
|
|
|
unsigned long s_objidx, d_objidx;
|
|
|
|
unsigned long s_off, d_off;
|
|
|
|
void *s_addr, *d_addr;
|
|
|
|
int s_size, d_size, size;
|
|
|
|
int written = 0;
|
|
|
|
|
|
|
|
s_size = d_size = class->size;
|
|
|
|
|
|
|
|
obj_to_location(src, &s_page, &s_objidx);
|
|
|
|
obj_to_location(dst, &d_page, &d_objidx);
|
|
|
|
|
|
|
|
s_off = obj_idx_to_offset(s_page, s_objidx, class->size);
|
|
|
|
d_off = obj_idx_to_offset(d_page, d_objidx, class->size);
|
|
|
|
|
|
|
|
if (s_off + class->size > PAGE_SIZE)
|
|
|
|
s_size = PAGE_SIZE - s_off;
|
|
|
|
|
|
|
|
if (d_off + class->size > PAGE_SIZE)
|
|
|
|
d_size = PAGE_SIZE - d_off;
|
|
|
|
|
|
|
|
s_addr = kmap_atomic(s_page);
|
|
|
|
d_addr = kmap_atomic(d_page);
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
size = min(s_size, d_size);
|
|
|
|
memcpy(d_addr + d_off, s_addr + s_off, size);
|
|
|
|
written += size;
|
|
|
|
|
|
|
|
if (written == class->size)
|
|
|
|
break;
|
|
|
|
|
2015-04-15 23:16:15 +00:00
|
|
|
s_off += size;
|
|
|
|
s_size -= size;
|
|
|
|
d_off += size;
|
|
|
|
d_size -= size;
|
|
|
|
|
|
|
|
if (s_off >= PAGE_SIZE) {
|
2015-04-15 23:15:30 +00:00
|
|
|
kunmap_atomic(d_addr);
|
|
|
|
kunmap_atomic(s_addr);
|
|
|
|
s_page = get_next_page(s_page);
|
|
|
|
BUG_ON(!s_page);
|
|
|
|
s_addr = kmap_atomic(s_page);
|
|
|
|
d_addr = kmap_atomic(d_page);
|
|
|
|
s_size = class->size - written;
|
|
|
|
s_off = 0;
|
|
|
|
}
|
|
|
|
|
2015-04-15 23:16:15 +00:00
|
|
|
if (d_off >= PAGE_SIZE) {
|
2015-04-15 23:15:30 +00:00
|
|
|
kunmap_atomic(d_addr);
|
|
|
|
d_page = get_next_page(d_page);
|
|
|
|
BUG_ON(!d_page);
|
|
|
|
d_addr = kmap_atomic(d_page);
|
|
|
|
d_size = class->size - written;
|
|
|
|
d_off = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
kunmap_atomic(d_addr);
|
|
|
|
kunmap_atomic(s_addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find alloced object in zspage from index object and
|
|
|
|
* return handle.
|
|
|
|
*/
|
|
|
|
static unsigned long find_alloced_obj(struct page *page, int index,
|
|
|
|
struct size_class *class)
|
|
|
|
{
|
|
|
|
unsigned long head;
|
|
|
|
int offset = 0;
|
|
|
|
unsigned long handle = 0;
|
|
|
|
void *addr = kmap_atomic(page);
|
|
|
|
|
|
|
|
if (!is_first_page(page))
|
|
|
|
offset = page->index;
|
|
|
|
offset += class->size * index;
|
|
|
|
|
|
|
|
while (offset < PAGE_SIZE) {
|
2015-04-15 23:15:39 +00:00
|
|
|
head = obj_to_head(class, page, addr + offset);
|
2015-04-15 23:15:30 +00:00
|
|
|
if (head & OBJ_ALLOCATED_TAG) {
|
|
|
|
handle = head & ~OBJ_ALLOCATED_TAG;
|
|
|
|
if (trypin_tag(handle))
|
|
|
|
break;
|
|
|
|
handle = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
offset += class->size;
|
|
|
|
index++;
|
|
|
|
}
|
|
|
|
|
|
|
|
kunmap_atomic(addr);
|
|
|
|
return handle;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct zs_compact_control {
|
|
|
|
/* Source page for migration which could be a subpage of zspage. */
|
|
|
|
struct page *s_page;
|
|
|
|
/* Destination page for migration which should be a first page
|
|
|
|
* of zspage. */
|
|
|
|
struct page *d_page;
|
|
|
|
/* Starting object index within @s_page which used for live object
|
|
|
|
* in the subpage. */
|
|
|
|
int index;
|
|
|
|
/* how many of objects are migrated */
|
|
|
|
int nr_migrated;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int migrate_zspage(struct zs_pool *pool, struct size_class *class,
|
|
|
|
struct zs_compact_control *cc)
|
|
|
|
{
|
|
|
|
unsigned long used_obj, free_obj;
|
|
|
|
unsigned long handle;
|
|
|
|
struct page *s_page = cc->s_page;
|
|
|
|
struct page *d_page = cc->d_page;
|
|
|
|
unsigned long index = cc->index;
|
|
|
|
int nr_migrated = 0;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
handle = find_alloced_obj(s_page, index, class);
|
|
|
|
if (!handle) {
|
|
|
|
s_page = get_next_page(s_page);
|
|
|
|
if (!s_page)
|
|
|
|
break;
|
|
|
|
index = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Stop if there is no more space */
|
|
|
|
if (zspage_full(d_page)) {
|
|
|
|
unpin_tag(handle);
|
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
used_obj = handle_to_obj(handle);
|
|
|
|
free_obj = obj_malloc(d_page, class, handle);
|
|
|
|
zs_object_copy(used_obj, free_obj, class);
|
|
|
|
index++;
|
|
|
|
record_obj(handle, free_obj);
|
|
|
|
unpin_tag(handle);
|
|
|
|
obj_free(pool, class, used_obj);
|
|
|
|
nr_migrated++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remember last position in this iteration */
|
|
|
|
cc->s_page = s_page;
|
|
|
|
cc->index = index;
|
|
|
|
cc->nr_migrated = nr_migrated;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct page *alloc_target_page(struct size_class *class)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
for (i = 0; i < _ZS_NR_FULLNESS_GROUPS; i++) {
|
|
|
|
page = class->fullness_list[i];
|
|
|
|
if (page) {
|
|
|
|
remove_zspage(page, class, i);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void putback_zspage(struct zs_pool *pool, struct size_class *class,
|
|
|
|
struct page *first_page)
|
|
|
|
{
|
|
|
|
int class_idx;
|
|
|
|
enum fullness_group fullness;
|
|
|
|
|
|
|
|
BUG_ON(!is_first_page(first_page));
|
|
|
|
|
|
|
|
get_zspage_mapping(first_page, &class_idx, &fullness);
|
|
|
|
insert_zspage(first_page, class, fullness);
|
|
|
|
fullness = fix_fullness_group(class, first_page);
|
UPSTREAM: zsmalloc: move pages_allocated to zs_pool
(cherry-pick from commit 13de8933c96b4557f667c337676f05274e017f83)
Currently, zram has no feature to limit memory so theoretically zram can
deplete system memory. Users have asked for a limit several times as even
without exhaustion zram makes it hard to control memory usage of the
platform. This patchset adds the feature.
Patch 1 makes zs_get_total_size_bytes faster because it would be used
frequently in later patches for the new feature.
Patch 2 changes zs_get_total_size_bytes's return unit from bytes to page
so that zsmalloc doesn't need unnecessary operation(ie, << PAGE_SHIFT).
Patch 3 adds new feature. I added the feature into zram layer, not
zsmalloc because limiation is zram's requirement, not zsmalloc so any
other user using zsmalloc(ie, zpool) shouldn't affected by unnecessary
branch of zsmalloc. In future, if every users of zsmalloc want the
feature, then, we could move the feature from client side to zsmalloc
easily but vice versa would be painful.
Patch 4 adds news facility to report maximum memory usage of zram so that
this avoids user polling frequently via /sys/block/zram0/ mem_used_total
and ensures transient max are not missed.
This patch (of 4):
pages_allocated has counted in size_class structure and when user of
zsmalloc want to see total_size_bytes, it should gather all of count from
each size_class to report the sum.
It's not bad if user don't see the value often but if user start to see
the value frequently, it would be not a good deal for performance pov.
This patch moves the count from size_class to zs_pool so it could reduce
memory footprint (from [255 * 8byte] to [sizeof(atomic_long_t)]).
Bug: 25951511
Change-Id: I05526575b81c95a12a7f8f0ef05040ed18b5fa6f
Signed-off-by: Minchan Kim <minchan@kernel.org>
Reviewed-by: Dan Streetman <ddstreet@ieee.org>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: <juno.choi@lge.com>
Cc: <seungho1.park@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Reviewed-by: David Horner <ds2horner@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-10-09 22:29:48 +00:00
|
|
|
if (fullness == ZS_EMPTY) {
|
2015-04-15 23:15:30 +00:00
|
|
|
zs_stat_dec(class, OBJ_ALLOCATED, get_maxobj_per_zspage(
|
|
|
|
class->size, class->pages_per_zspage));
|
UPSTREAM: zsmalloc: move pages_allocated to zs_pool
(cherry-pick from commit 13de8933c96b4557f667c337676f05274e017f83)
Currently, zram has no feature to limit memory so theoretically zram can
deplete system memory. Users have asked for a limit several times as even
without exhaustion zram makes it hard to control memory usage of the
platform. This patchset adds the feature.
Patch 1 makes zs_get_total_size_bytes faster because it would be used
frequently in later patches for the new feature.
Patch 2 changes zs_get_total_size_bytes's return unit from bytes to page
so that zsmalloc doesn't need unnecessary operation(ie, << PAGE_SHIFT).
Patch 3 adds new feature. I added the feature into zram layer, not
zsmalloc because limiation is zram's requirement, not zsmalloc so any
other user using zsmalloc(ie, zpool) shouldn't affected by unnecessary
branch of zsmalloc. In future, if every users of zsmalloc want the
feature, then, we could move the feature from client side to zsmalloc
easily but vice versa would be painful.
Patch 4 adds news facility to report maximum memory usage of zram so that
this avoids user polling frequently via /sys/block/zram0/ mem_used_total
and ensures transient max are not missed.
This patch (of 4):
pages_allocated has counted in size_class structure and when user of
zsmalloc want to see total_size_bytes, it should gather all of count from
each size_class to report the sum.
It's not bad if user don't see the value often but if user start to see
the value frequently, it would be not a good deal for performance pov.
This patch moves the count from size_class to zs_pool so it could reduce
memory footprint (from [255 * 8byte] to [sizeof(atomic_long_t)]).
Bug: 25951511
Change-Id: I05526575b81c95a12a7f8f0ef05040ed18b5fa6f
Signed-off-by: Minchan Kim <minchan@kernel.org>
Reviewed-by: Dan Streetman <ddstreet@ieee.org>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: <juno.choi@lge.com>
Cc: <seungho1.park@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Reviewed-by: David Horner <ds2horner@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-10-09 22:29:48 +00:00
|
|
|
atomic_long_sub(class->pages_per_zspage,
|
|
|
|
&pool->pages_allocated);
|
2015-04-15 23:15:30 +00:00
|
|
|
|
2012-01-09 22:51:56 +00:00
|
|
|
free_zspage(first_page);
|
UPSTREAM: zsmalloc: move pages_allocated to zs_pool
(cherry-pick from commit 13de8933c96b4557f667c337676f05274e017f83)
Currently, zram has no feature to limit memory so theoretically zram can
deplete system memory. Users have asked for a limit several times as even
without exhaustion zram makes it hard to control memory usage of the
platform. This patchset adds the feature.
Patch 1 makes zs_get_total_size_bytes faster because it would be used
frequently in later patches for the new feature.
Patch 2 changes zs_get_total_size_bytes's return unit from bytes to page
so that zsmalloc doesn't need unnecessary operation(ie, << PAGE_SHIFT).
Patch 3 adds new feature. I added the feature into zram layer, not
zsmalloc because limiation is zram's requirement, not zsmalloc so any
other user using zsmalloc(ie, zpool) shouldn't affected by unnecessary
branch of zsmalloc. In future, if every users of zsmalloc want the
feature, then, we could move the feature from client side to zsmalloc
easily but vice versa would be painful.
Patch 4 adds news facility to report maximum memory usage of zram so that
this avoids user polling frequently via /sys/block/zram0/ mem_used_total
and ensures transient max are not missed.
This patch (of 4):
pages_allocated has counted in size_class structure and when user of
zsmalloc want to see total_size_bytes, it should gather all of count from
each size_class to report the sum.
It's not bad if user don't see the value often but if user start to see
the value frequently, it would be not a good deal for performance pov.
This patch moves the count from size_class to zs_pool so it could reduce
memory footprint (from [255 * 8byte] to [sizeof(atomic_long_t)]).
Bug: 25951511
Change-Id: I05526575b81c95a12a7f8f0ef05040ed18b5fa6f
Signed-off-by: Minchan Kim <minchan@kernel.org>
Reviewed-by: Dan Streetman <ddstreet@ieee.org>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: <juno.choi@lge.com>
Cc: <seungho1.park@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Reviewed-by: David Horner <ds2horner@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-10-09 22:29:48 +00:00
|
|
|
}
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
2015-04-15 23:15:30 +00:00
|
|
|
|
|
|
|
static struct page *isolate_source_page(struct size_class *class)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = class->fullness_list[ZS_ALMOST_EMPTY];
|
|
|
|
if (page)
|
|
|
|
remove_zspage(page, class, ZS_ALMOST_EMPTY);
|
|
|
|
|
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long __zs_compact(struct zs_pool *pool,
|
|
|
|
struct size_class *class)
|
|
|
|
{
|
|
|
|
int nr_to_migrate;
|
|
|
|
struct zs_compact_control cc;
|
|
|
|
struct page *src_page;
|
|
|
|
struct page *dst_page = NULL;
|
|
|
|
unsigned long nr_total_migrated = 0;
|
|
|
|
|
|
|
|
cond_resched();
|
|
|
|
|
|
|
|
spin_lock(&class->lock);
|
|
|
|
while ((src_page = isolate_source_page(class))) {
|
|
|
|
|
|
|
|
BUG_ON(!is_first_page(src_page));
|
|
|
|
|
|
|
|
/* The goal is to migrate all live objects in source page */
|
|
|
|
nr_to_migrate = src_page->inuse;
|
|
|
|
cc.index = 0;
|
|
|
|
cc.s_page = src_page;
|
|
|
|
|
|
|
|
while ((dst_page = alloc_target_page(class))) {
|
|
|
|
cc.d_page = dst_page;
|
|
|
|
/*
|
|
|
|
* If there is no more space in dst_page, try to
|
|
|
|
* allocate another zspage.
|
|
|
|
*/
|
|
|
|
if (!migrate_zspage(pool, class, &cc))
|
|
|
|
break;
|
|
|
|
|
|
|
|
putback_zspage(pool, class, dst_page);
|
|
|
|
nr_total_migrated += cc.nr_migrated;
|
|
|
|
nr_to_migrate -= cc.nr_migrated;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Stop if we couldn't find slot */
|
|
|
|
if (dst_page == NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
putback_zspage(pool, class, dst_page);
|
|
|
|
putback_zspage(pool, class, src_page);
|
|
|
|
spin_unlock(&class->lock);
|
|
|
|
nr_total_migrated += cc.nr_migrated;
|
|
|
|
cond_resched();
|
|
|
|
spin_lock(&class->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (src_page)
|
|
|
|
putback_zspage(pool, class, src_page);
|
|
|
|
|
|
|
|
spin_unlock(&class->lock);
|
|
|
|
|
|
|
|
return nr_total_migrated;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long zs_compact(struct zs_pool *pool)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
unsigned long nr_migrated = 0;
|
|
|
|
struct size_class *class;
|
|
|
|
|
|
|
|
for (i = zs_size_classes - 1; i >= 0; i--) {
|
|
|
|
class = pool->size_class[i];
|
|
|
|
if (!class)
|
|
|
|
continue;
|
|
|
|
if (class->index != i)
|
|
|
|
continue;
|
|
|
|
nr_migrated += __zs_compact(pool, class);
|
|
|
|
}
|
|
|
|
|
|
|
|
return nr_migrated;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(zs_compact);
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2012-05-03 06:40:40 +00:00
|
|
|
/**
|
2014-12-19 00:17:40 +00:00
|
|
|
* zs_create_pool - Creates an allocation pool to work from.
|
|
|
|
* @flags: allocation flags used to allocate pool metadata
|
2012-07-02 21:15:51 +00:00
|
|
|
*
|
2014-12-19 00:17:40 +00:00
|
|
|
* This function must be called before anything when using
|
|
|
|
* the zsmalloc allocator.
|
2012-07-02 21:15:51 +00:00
|
|
|
*
|
2014-12-19 00:17:40 +00:00
|
|
|
* On success, a pointer to the newly created pool is returned,
|
|
|
|
* otherwise NULL.
|
2013-05-20 19:18:14 +00:00
|
|
|
*/
|
2015-02-12 23:00:51 +00:00
|
|
|
struct zs_pool *zs_create_pool(char *name, gfp_t flags)
|
2012-01-09 22:51:56 +00:00
|
|
|
{
|
2014-12-19 00:17:40 +00:00
|
|
|
int i;
|
|
|
|
struct zs_pool *pool;
|
|
|
|
struct size_class *prev_class = NULL;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
pool = kzalloc(sizeof(*pool), GFP_KERNEL);
|
|
|
|
if (!pool)
|
|
|
|
return NULL;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
pool->size_class = kcalloc(zs_size_classes, sizeof(struct size_class *),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!pool->size_class) {
|
|
|
|
kfree(pool);
|
|
|
|
return NULL;
|
|
|
|
}
|
2012-01-09 22:51:56 +00:00
|
|
|
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
pool->name = kstrdup(name, GFP_KERNEL);
|
|
|
|
if (!pool->name)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
if (create_handle_cache(pool))
|
|
|
|
goto err;
|
|
|
|
|
2012-07-18 16:55:55 +00:00
|
|
|
/*
|
2014-12-19 00:17:40 +00:00
|
|
|
* Iterate reversly, because, size of size_class that we want to use
|
|
|
|
* for merging should be larger or equal to current size.
|
2012-07-18 16:55:55 +00:00
|
|
|
*/
|
2014-12-19 00:17:40 +00:00
|
|
|
for (i = zs_size_classes - 1; i >= 0; i--) {
|
|
|
|
int size;
|
|
|
|
int pages_per_zspage;
|
|
|
|
struct size_class *class;
|
2012-07-18 16:55:55 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
size = ZS_MIN_ALLOC_SIZE + i * ZS_SIZE_CLASS_DELTA;
|
|
|
|
if (size > ZS_MAX_ALLOC_SIZE)
|
|
|
|
size = ZS_MAX_ALLOC_SIZE;
|
|
|
|
pages_per_zspage = get_pages_per_zspage(size);
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
/*
|
|
|
|
* size_class is used for normal zsmalloc operation such
|
|
|
|
* as alloc/free for that size. Although it is natural that we
|
|
|
|
* have one size_class for each size, there is a chance that we
|
|
|
|
* can get more memory utilization if we use one size_class for
|
|
|
|
* many different sizes whose size_class have same
|
|
|
|
* characteristics. So, we makes size_class point to
|
|
|
|
* previous size_class if possible.
|
|
|
|
*/
|
|
|
|
if (prev_class) {
|
|
|
|
if (can_merge(prev_class, size, pages_per_zspage)) {
|
|
|
|
pool->size_class[i] = prev_class;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class = kzalloc(sizeof(struct size_class), GFP_KERNEL);
|
|
|
|
if (!class)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
class->size = size;
|
|
|
|
class->index = i;
|
|
|
|
class->pages_per_zspage = pages_per_zspage;
|
2015-04-15 23:15:39 +00:00
|
|
|
if (pages_per_zspage == 1 &&
|
|
|
|
get_maxobj_per_zspage(size, pages_per_zspage) == 1)
|
|
|
|
class->huge = true;
|
2014-12-19 00:17:40 +00:00
|
|
|
spin_lock_init(&class->lock);
|
|
|
|
pool->size_class[i] = class;
|
|
|
|
|
|
|
|
prev_class = class;
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
pool->flags = flags;
|
2012-07-02 21:15:52 +00:00
|
|
|
|
2015-02-12 23:00:54 +00:00
|
|
|
if (zs_pool_stat_create(name, pool))
|
|
|
|
goto err;
|
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
return pool;
|
|
|
|
|
|
|
|
err:
|
|
|
|
zs_destroy_pool(pool);
|
|
|
|
return NULL;
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
2014-12-19 00:17:40 +00:00
|
|
|
EXPORT_SYMBOL_GPL(zs_create_pool);
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
void zs_destroy_pool(struct zs_pool *pool)
|
2012-01-09 22:51:56 +00:00
|
|
|
{
|
2014-12-19 00:17:40 +00:00
|
|
|
int i;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2015-02-12 23:00:54 +00:00
|
|
|
zs_pool_stat_destroy(pool);
|
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
for (i = 0; i < zs_size_classes; i++) {
|
|
|
|
int fg;
|
|
|
|
struct size_class *class = pool->size_class[i];
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
if (!class)
|
|
|
|
continue;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
if (class->index != i)
|
|
|
|
continue;
|
2012-01-09 22:51:56 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
for (fg = 0; fg < _ZS_NR_FULLNESS_GROUPS; fg++) {
|
|
|
|
if (class->fullness_list[fg]) {
|
|
|
|
pr_info("Freeing non-empty class with size %db, fullness group %d\n",
|
|
|
|
class->size, fg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
kfree(class);
|
|
|
|
}
|
2012-07-18 16:55:56 +00:00
|
|
|
|
UPSTREAM: zsmalloc: decouple handle and object
(cherry-pick from commit 2e40e163a25af3bd35d128d3e2e005916de5cce6)
Recently, we started to use zram heavily and some of issues
popped.
1) external fragmentation
I got a report from Juneho Choi that fork failed although there are plenty
of free pages in the system. His investigation revealed zram is one of
the culprit to make heavy fragmentation so there was no more contiguous
16K page for pgd to fork in the ARM.
2) non-movable pages
Other problem of zram now is that inherently, user want to use zram as
swap in small memory system so they use zRAM with CMA to use memory
efficiently. However, unfortunately, it doesn't work well because zRAM
cannot use CMA's movable pages unless it doesn't support compaction. I
got several reports about that OOM happened with zram although there are
lots of swap space and free space in CMA area.
3) internal fragmentation
zRAM has started support memory limitation feature to limit memory usage
and I sent a patchset(https://lkml.org/lkml/2014/9/21/148) for VM to be
harmonized with zram-swap to stop anonymous page reclaim if zram consumed
memory up to the limit although there are free space on the swap. One
problem for that direction is zram has no way to know any hole in memory
space zsmalloc allocated by internal fragmentation so zram would regard
swap is full although there are free space in zsmalloc. For solving the
issue, zram want to trigger compaction of zsmalloc before it decides full
or not.
This patchset is first step to support above issues. For that, it adds
indirect layer between handle and object location and supports manual
compaction to solve 3th problem first of all.
After this patchset got merged, next step is to make VM aware of zsmalloc
compaction so that generic compaction will move zsmalloced-pages
automatically in runtime.
In my imaginary experiment(ie, high compress ratio data with heavy swap
in/out on 8G zram-swap), data is as follows,
Before =
zram allocated object : 60212066 bytes
zram total used: 140103680 bytes
ratio: 42.98 percent
MemFree: 840192 kB
Compaction
After =
frag ratio after compaction
zram allocated object : 60212066 bytes
zram total used: 76185600 bytes
ratio: 79.03 percent
MemFree: 901932 kB
Juneho reported below in his real platform with small aging.
So, I think the benefit would be bigger in real aging system
for a long time.
- frag_ratio increased 3% (ie, higher is better)
- memfree increased about 6MB
- In buddy info, Normal 2^3: 4, 2^2: 1: 2^1 increased, Highmem: 2^1 21 increased
frag ratio after swap fragment
used : 156677 kbytes
total: 166092 kbytes
frag_ratio : 94
meminfo before compaction
MemFree: 83724 kB
Node 0, zone Normal 13642 1364 57 10 61 17 9 5 4 0 0
Node 0, zone HighMem 425 29 1 0 0 0 0 0 0 0 0
num_migrated : 23630
compaction done
frag ratio after compaction
used : 156673 kbytes
total: 160564 kbytes
frag_ratio : 97
meminfo after compaction
MemFree: 89060 kB
Node 0, zone Normal 14076 1544 67 14 61 17 9 5 4 0 0
Node 0, zone HighMem 863 50 1 0 0 0 0 0 0 0 0
This patchset adds more logics(about 480 lines) in zsmalloc but when I
tested heavy swapin/out program, the regression for swapin/out speed is
marginal because most of overheads were caused by compress/decompress and
other MM reclaim stuff.
This patch (of 7):
Currently, handle of zsmalloc encodes object's location directly so it
makes support of migration hard.
This patch decouples handle and object via adding indirect layer. For
that, it allocates handle dynamically and returns it to user. The handle
is the address allocated by slab allocation so it's unique and we could
keep object's location in the memory space allocated for handle.
With it, we can change object's position without changing handle itself.
Bug: 25951511
Change-Id: Id50a98341f63c4e1bb39589ca992661486469dca
Signed-off-by: Minchan Kim <minchan@kernel.org>
Cc: Juneho Choi <juno.choi@lge.com>
Cc: Gunho Lee <gunho.lee@lge.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Seth Jennings <sjennings@variantweb.net>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-04-15 23:15:23 +00:00
|
|
|
destroy_handle_cache(pool);
|
2014-12-19 00:17:40 +00:00
|
|
|
kfree(pool->size_class);
|
2015-02-12 23:00:54 +00:00
|
|
|
kfree(pool->name);
|
2014-12-19 00:17:40 +00:00
|
|
|
kfree(pool);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(zs_destroy_pool);
|
2012-07-02 21:15:52 +00:00
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
static int __init zs_init(void)
|
|
|
|
{
|
|
|
|
int ret = zs_register_cpu_notifier();
|
|
|
|
|
2015-02-12 23:00:54 +00:00
|
|
|
if (ret)
|
|
|
|
goto notifier_fail;
|
2014-12-19 00:17:40 +00:00
|
|
|
|
|
|
|
init_zs_size_classes();
|
|
|
|
|
|
|
|
#ifdef CONFIG_ZPOOL
|
|
|
|
zpool_register_driver(&zs_zpool_driver);
|
|
|
|
#endif
|
2015-02-12 23:00:54 +00:00
|
|
|
|
|
|
|
ret = zs_stat_init();
|
|
|
|
if (ret) {
|
|
|
|
pr_err("zs stat initialization failed\n");
|
|
|
|
goto stat_fail;
|
|
|
|
}
|
2014-12-19 00:17:40 +00:00
|
|
|
return 0;
|
2015-02-12 23:00:54 +00:00
|
|
|
|
|
|
|
stat_fail:
|
|
|
|
#ifdef CONFIG_ZPOOL
|
|
|
|
zpool_unregister_driver(&zs_zpool_driver);
|
|
|
|
#endif
|
|
|
|
notifier_fail:
|
|
|
|
zs_unregister_cpu_notifier();
|
|
|
|
|
|
|
|
return ret;
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
|
|
|
|
2014-12-19 00:17:40 +00:00
|
|
|
static void __exit zs_exit(void)
|
2012-01-09 22:51:56 +00:00
|
|
|
{
|
2014-12-19 00:17:40 +00:00
|
|
|
#ifdef CONFIG_ZPOOL
|
|
|
|
zpool_unregister_driver(&zs_zpool_driver);
|
|
|
|
#endif
|
|
|
|
zs_unregister_cpu_notifier();
|
2015-02-12 23:00:54 +00:00
|
|
|
|
|
|
|
zs_stat_exit();
|
2012-01-09 22:51:56 +00:00
|
|
|
}
|
2012-06-20 01:31:11 +00:00
|
|
|
|
|
|
|
module_init(zs_init);
|
|
|
|
module_exit(zs_exit);
|
|
|
|
|
|
|
|
MODULE_LICENSE("Dual BSD/GPL");
|
|
|
|
MODULE_AUTHOR("Nitin Gupta <ngupta@vflare.org>");
|