Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > linux.kernel > #1556572 > unrolled thread
| Started by | Vitaly Wool <vitalywool@gmail.com> |
|---|---|
| First post | 2017-01-11 16:10 +0100 |
| Last post | 2017-01-12 19:00 +0100 |
| Articles | 5 — 2 participants |
Back to article view | Back to linux.kernel
This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by
below is the oldest one visible, not the original post.
[PATCH/RESEND v2 3/5] z3fold: extend compaction function Vitaly Wool <vitalywool@gmail.com> - 2017-01-11 16:10 +0100
Re: [PATCH/RESEND v2 3/5] z3fold: extend compaction function Dan Streetman <ddstreet@ieee.org> - 2017-01-11 17:30 +0100
Re: [PATCH/RESEND v2 3/5] z3fold: extend compaction function Vitaly Wool <vitalywool@gmail.com> - 2017-01-11 17:50 +0100
Re: [PATCH/RESEND v2 3/5] z3fold: extend compaction function Vitaly Wool <vitalywool@gmail.com> - 2017-01-11 22:00 +0100
Re: [PATCH/RESEND v2 3/5] z3fold: extend compaction function Dan Streetman <ddstreet@ieee.org> - 2017-01-12 19:00 +0100
| From | Vitaly Wool <vitalywool@gmail.com> |
|---|---|
| Date | 2017-01-11 16:10 +0100 |
| Subject | [PATCH/RESEND v2 3/5] z3fold: extend compaction function |
| Message-ID | <sYsHf-8rV-35@gated-at.bofh.it> |
z3fold_compact_page() currently only handles the situation when
there's a single middle chunk within the z3fold page. However it
may be worth it to move middle chunk closer to either first or
last chunk, whichever is there, if the gap between them is big
enough.
This patch adds the relevant code, using BIG_CHUNK_GAP define as
a threshold for middle chunk to be worth moving.
Signed-off-by: Vitaly Wool <vitalywool@gmail.com>
---
mm/z3fold.c | 26 +++++++++++++++++++++++++-
1 file changed, 25 insertions(+), 1 deletion(-)
diff --git a/mm/z3fold.c b/mm/z3fold.c
index 98ab01f..fca3310 100644
--- a/mm/z3fold.c
+++ b/mm/z3fold.c
@@ -268,6 +268,7 @@ static inline void *mchunk_memmove(struct z3fold_header *zhdr,
zhdr->middle_chunks << CHUNK_SHIFT);
}
+#define BIG_CHUNK_GAP 3
/* Has to be called with lock held */
static int z3fold_compact_page(struct z3fold_header *zhdr)
{
@@ -286,8 +287,31 @@ static int z3fold_compact_page(struct z3fold_header *zhdr)
zhdr->middle_chunks = 0;
zhdr->start_middle = 0;
zhdr->first_num++;
+ return 1;
}
- return 1;
+
+ /*
+ * moving data is expensive, so let's only do that if
+ * there's substantial gain (at least BIG_CHUNK_GAP chunks)
+ */
+ if (zhdr->first_chunks != 0 && zhdr->last_chunks == 0 &&
+ zhdr->start_middle - (zhdr->first_chunks + ZHDR_CHUNKS) >=
+ BIG_CHUNK_GAP) {
+ mchunk_memmove(zhdr, zhdr->first_chunks + 1);
+ zhdr->start_middle = zhdr->first_chunks + 1;
+ return 1;
+ } else if (zhdr->last_chunks != 0 && zhdr->first_chunks == 0 &&
+ TOTAL_CHUNKS - (zhdr->last_chunks + zhdr->start_middle
+ + zhdr->middle_chunks) >=
+ BIG_CHUNK_GAP) {
+ unsigned short new_start = NCHUNKS - zhdr->last_chunks -
+ zhdr->middle_chunks;
+ mchunk_memmove(zhdr, new_start);
+ zhdr->start_middle = new_start;
+ return 1;
+ }
+
+ return 0;
}
/**
--
2.4.2
[toc] | [next] | [standalone]
| From | Dan Streetman <ddstreet@ieee.org> |
|---|---|
| Date | 2017-01-11 17:30 +0100 |
| Message-ID | <sYtWG-In-35@gated-at.bofh.it> |
| In reply to | #1556572 |
On Wed, Jan 11, 2017 at 10:06 AM, Vitaly Wool <vitalywool@gmail.com> wrote:
> z3fold_compact_page() currently only handles the situation when
> there's a single middle chunk within the z3fold page. However it
> may be worth it to move middle chunk closer to either first or
> last chunk, whichever is there, if the gap between them is big
> enough.
>
> This patch adds the relevant code, using BIG_CHUNK_GAP define as
> a threshold for middle chunk to be worth moving.
>
> Signed-off-by: Vitaly Wool <vitalywool@gmail.com>
> ---
> mm/z3fold.c | 26 +++++++++++++++++++++++++-
> 1 file changed, 25 insertions(+), 1 deletion(-)
>
> diff --git a/mm/z3fold.c b/mm/z3fold.c
> index 98ab01f..fca3310 100644
> --- a/mm/z3fold.c
> +++ b/mm/z3fold.c
> @@ -268,6 +268,7 @@ static inline void *mchunk_memmove(struct z3fold_header *zhdr,
> zhdr->middle_chunks << CHUNK_SHIFT);
> }
>
> +#define BIG_CHUNK_GAP 3
> /* Has to be called with lock held */
> static int z3fold_compact_page(struct z3fold_header *zhdr)
> {
> @@ -286,8 +287,31 @@ static int z3fold_compact_page(struct z3fold_header *zhdr)
> zhdr->middle_chunks = 0;
> zhdr->start_middle = 0;
> zhdr->first_num++;
> + return 1;
> }
> - return 1;
> +
> + /*
> + * moving data is expensive, so let's only do that if
> + * there's substantial gain (at least BIG_CHUNK_GAP chunks)
> + */
> + if (zhdr->first_chunks != 0 && zhdr->last_chunks == 0 &&
> + zhdr->start_middle - (zhdr->first_chunks + ZHDR_CHUNKS) >=
> + BIG_CHUNK_GAP) {
> + mchunk_memmove(zhdr, zhdr->first_chunks + 1);
> + zhdr->start_middle = zhdr->first_chunks + 1;
this should be first_chunks + ZHDR_CHUNKS, not + 1.
> + return 1;
> + } else if (zhdr->last_chunks != 0 && zhdr->first_chunks == 0 &&
> + TOTAL_CHUNKS - (zhdr->last_chunks + zhdr->start_middle
> + + zhdr->middle_chunks) >=
> + BIG_CHUNK_GAP) {
> + unsigned short new_start = NCHUNKS - zhdr->last_chunks -
this should be TOTAL_CHUNKS, not NCHUNKS.
> + zhdr->middle_chunks;
> + mchunk_memmove(zhdr, new_start);
> + zhdr->start_middle = new_start;
> + return 1;
> + }
> +
> + return 0;
> }
>
> /**
> --
> 2.4.2
[toc] | [prev] | [next] | [standalone]
| From | Vitaly Wool <vitalywool@gmail.com> |
|---|---|
| Date | 2017-01-11 17:50 +0100 |
| Message-ID | <sYug1-OR-33@gated-at.bofh.it> |
| In reply to | #1556697 |
On Wed, Jan 11, 2017 at 5:28 PM, Dan Streetman <ddstreet@ieee.org> wrote:
> On Wed, Jan 11, 2017 at 10:06 AM, Vitaly Wool <vitalywool@gmail.com> wrote:
>> z3fold_compact_page() currently only handles the situation when
>> there's a single middle chunk within the z3fold page. However it
>> may be worth it to move middle chunk closer to either first or
>> last chunk, whichever is there, if the gap between them is big
>> enough.
>>
>> This patch adds the relevant code, using BIG_CHUNK_GAP define as
>> a threshold for middle chunk to be worth moving.
>>
>> Signed-off-by: Vitaly Wool <vitalywool@gmail.com>
>> ---
>> mm/z3fold.c | 26 +++++++++++++++++++++++++-
>> 1 file changed, 25 insertions(+), 1 deletion(-)
>>
>> diff --git a/mm/z3fold.c b/mm/z3fold.c
>> index 98ab01f..fca3310 100644
>> --- a/mm/z3fold.c
>> +++ b/mm/z3fold.c
>> @@ -268,6 +268,7 @@ static inline void *mchunk_memmove(struct z3fold_header *zhdr,
>> zhdr->middle_chunks << CHUNK_SHIFT);
>> }
>>
>> +#define BIG_CHUNK_GAP 3
>> /* Has to be called with lock held */
>> static int z3fold_compact_page(struct z3fold_header *zhdr)
>> {
>> @@ -286,8 +287,31 @@ static int z3fold_compact_page(struct z3fold_header *zhdr)
>> zhdr->middle_chunks = 0;
>> zhdr->start_middle = 0;
>> zhdr->first_num++;
>> + return 1;
>> }
>> - return 1;
>> +
>> + /*
>> + * moving data is expensive, so let's only do that if
>> + * there's substantial gain (at least BIG_CHUNK_GAP chunks)
>> + */
>> + if (zhdr->first_chunks != 0 && zhdr->last_chunks == 0 &&
>> + zhdr->start_middle - (zhdr->first_chunks + ZHDR_CHUNKS) >=
>> + BIG_CHUNK_GAP) {
>> + mchunk_memmove(zhdr, zhdr->first_chunks + 1);
>> + zhdr->start_middle = zhdr->first_chunks + 1;
>
> this should be first_chunks + ZHDR_CHUNKS, not + 1.
>
>> + return 1;
>> + } else if (zhdr->last_chunks != 0 && zhdr->first_chunks == 0 &&
>> + TOTAL_CHUNKS - (zhdr->last_chunks + zhdr->start_middle
>> + + zhdr->middle_chunks) >=
>> + BIG_CHUNK_GAP) {
>> + unsigned short new_start = NCHUNKS - zhdr->last_chunks -
>
> this should be TOTAL_CHUNKS, not NCHUNKS.
Right :/
>> + zhdr->middle_chunks;
>> + mchunk_memmove(zhdr, new_start);
>> + zhdr->start_middle = new_start;
>> + return 1;
>> + }
>> +
>> + return 0;
>> }
>>
>> /**
>> --
>> 2.4.2
[toc] | [prev] | [next] | [standalone]
| From | Vitaly Wool <vitalywool@gmail.com> |
|---|---|
| Date | 2017-01-11 22:00 +0100 |
| Message-ID | <sYy9Y-3aX-33@gated-at.bofh.it> |
| In reply to | #1556713 |
On Wed, 11 Jan 2017 17:43:13 +0100
Vitaly Wool <vitalywool@gmail.com> wrote:
> On Wed, Jan 11, 2017 at 5:28 PM, Dan Streetman <ddstreet@ieee.org> wrote:
> > On Wed, Jan 11, 2017 at 10:06 AM, Vitaly Wool <vitalywool@gmail.com> wrote:
> >> z3fold_compact_page() currently only handles the situation when
> >> there's a single middle chunk within the z3fold page. However it
> >> may be worth it to move middle chunk closer to either first or
> >> last chunk, whichever is there, if the gap between them is big
> >> enough.
> >>
> >> This patch adds the relevant code, using BIG_CHUNK_GAP define as
> >> a threshold for middle chunk to be worth moving.
> >>
> >> Signed-off-by: Vitaly Wool <vitalywool@gmail.com>
> >> ---
> >> mm/z3fold.c | 26 +++++++++++++++++++++++++-
> >> 1 file changed, 25 insertions(+), 1 deletion(-)
> >>
> >> diff --git a/mm/z3fold.c b/mm/z3fold.c
> >> index 98ab01f..fca3310 100644
> >> --- a/mm/z3fold.c
> >> +++ b/mm/z3fold.c
> >> @@ -268,6 +268,7 @@ static inline void *mchunk_memmove(struct z3fold_header *zhdr,
> >> zhdr->middle_chunks << CHUNK_SHIFT);
> >> }
> >>
> >> +#define BIG_CHUNK_GAP 3
> >> /* Has to be called with lock held */
> >> static int z3fold_compact_page(struct z3fold_header *zhdr)
> >> {
> >> @@ -286,8 +287,31 @@ static int z3fold_compact_page(struct z3fold_header *zhdr)
> >> zhdr->middle_chunks = 0;
> >> zhdr->start_middle = 0;
> >> zhdr->first_num++;
> >> + return 1;
> >> }
> >> - return 1;
> >> +
> >> + /*
> >> + * moving data is expensive, so let's only do that if
> >> + * there's substantial gain (at least BIG_CHUNK_GAP chunks)
> >> + */
> >> + if (zhdr->first_chunks != 0 && zhdr->last_chunks == 0 &&
> >> + zhdr->start_middle - (zhdr->first_chunks + ZHDR_CHUNKS) >=
> >> + BIG_CHUNK_GAP) {
> >> + mchunk_memmove(zhdr, zhdr->first_chunks + 1);
> >> + zhdr->start_middle = zhdr->first_chunks + 1;
> >
> > this should be first_chunks + ZHDR_CHUNKS, not + 1.
> >
> >> + return 1;
> >> + } else if (zhdr->last_chunks != 0 && zhdr->first_chunks == 0 &&
> >> + TOTAL_CHUNKS - (zhdr->last_chunks + zhdr->start_middle
> >> + + zhdr->middle_chunks) >=
> >> + BIG_CHUNK_GAP) {
> >> + unsigned short new_start = NCHUNKS - zhdr->last_chunks -
> >
> > this should be TOTAL_CHUNKS, not NCHUNKS.
>
> Right :/
So here we go:
z3fold_compact_page() currently only handles the situation when
there's a single middle chunk within the z3fold page. However it
may be worth it to move middle chunk closer to either first or
last chunk, whichever is there, if the gap between them is big
enough.
This patch adds the relevant code, using BIG_CHUNK_GAP define as
a threshold for middle chunk to be worth moving.
Signed-off-by: Vitaly Wool <vitalywool@gmail.com>
---
mm/z3fold.c | 26 +++++++++++++++++++++++++-
1 file changed, 25 insertions(+), 1 deletion(-)
diff --git a/mm/z3fold.c b/mm/z3fold.c
index 98ab01f..fca3310 100644
--- a/mm/z3fold.c
+++ b/mm/z3fold.c
@@ -268,6 +268,7 @@ static inline void *mchunk_memmove(struct z3fold_header *zhdr,
zhdr->middle_chunks << CHUNK_SHIFT);
}
+#define BIG_CHUNK_GAP 3
/* Has to be called with lock held */
static int z3fold_compact_page(struct z3fold_header *zhdr)
{
@@ -286,8 +287,31 @@ static int z3fold_compact_page(struct z3fold_header *zhdr)
zhdr->middle_chunks = 0;
zhdr->start_middle = 0;
zhdr->first_num++;
+ return 1;
}
- return 1;
+
+ /*
+ * moving data is expensive, so let's only do that if
+ * there's substantial gain (at least BIG_CHUNK_GAP chunks)
+ */
+ if (zhdr->first_chunks != 0 && zhdr->last_chunks == 0 &&
+ zhdr->start_middle - (zhdr->first_chunks + ZHDR_CHUNKS) >=
+ BIG_CHUNK_GAP) {
+ mchunk_memmove(zhdr, zhdr->first_chunks + ZHDR_CHUNKS);
+ zhdr->start_middle = zhdr->first_chunks + ZHDR_CHUNKS;
+ return 1;
+ } else if (zhdr->last_chunks != 0 && zhdr->first_chunks == 0 &&
+ TOTAL_CHUNKS - (zhdr->last_chunks + zhdr->start_middle
+ + zhdr->middle_chunks) >=
+ BIG_CHUNK_GAP) {
+ unsigned short new_start = TOTAL_CHUNKS - zhdr->last_chunks -
+ zhdr->middle_chunks;
+ mchunk_memmove(zhdr, new_start);
+ zhdr->start_middle = new_start;
+ return 1;
+ }
+
+ return 0;
}
/**
--
2.4.2
[toc] | [prev] | [next] | [standalone]
| From | Dan Streetman <ddstreet@ieee.org> |
|---|---|
| Date | 2017-01-12 19:00 +0100 |
| Message-ID | <sYRPk-6SY-47@gated-at.bofh.it> |
| In reply to | #1556924 |
On Wed, Jan 11, 2017 at 3:52 PM, Vitaly Wool <vitalywool@gmail.com> wrote:
> On Wed, 11 Jan 2017 17:43:13 +0100
> Vitaly Wool <vitalywool@gmail.com> wrote:
>
>> On Wed, Jan 11, 2017 at 5:28 PM, Dan Streetman <ddstreet@ieee.org> wrote:
>> > On Wed, Jan 11, 2017 at 10:06 AM, Vitaly Wool <vitalywool@gmail.com> wrote:
>> >> z3fold_compact_page() currently only handles the situation when
>> >> there's a single middle chunk within the z3fold page. However it
>> >> may be worth it to move middle chunk closer to either first or
>> >> last chunk, whichever is there, if the gap between them is big
>> >> enough.
>> >>
>> >> This patch adds the relevant code, using BIG_CHUNK_GAP define as
>> >> a threshold for middle chunk to be worth moving.
>> >>
>> >> Signed-off-by: Vitaly Wool <vitalywool@gmail.com>
>> >> ---
>> >> mm/z3fold.c | 26 +++++++++++++++++++++++++-
>> >> 1 file changed, 25 insertions(+), 1 deletion(-)
>> >>
>> >> diff --git a/mm/z3fold.c b/mm/z3fold.c
>> >> index 98ab01f..fca3310 100644
>> >> --- a/mm/z3fold.c
>> >> +++ b/mm/z3fold.c
>> >> @@ -268,6 +268,7 @@ static inline void *mchunk_memmove(struct z3fold_header *zhdr,
>> >> zhdr->middle_chunks << CHUNK_SHIFT);
>> >> }
>> >>
>> >> +#define BIG_CHUNK_GAP 3
>> >> /* Has to be called with lock held */
>> >> static int z3fold_compact_page(struct z3fold_header *zhdr)
>> >> {
>> >> @@ -286,8 +287,31 @@ static int z3fold_compact_page(struct z3fold_header *zhdr)
>> >> zhdr->middle_chunks = 0;
>> >> zhdr->start_middle = 0;
>> >> zhdr->first_num++;
>> >> + return 1;
>> >> }
>> >> - return 1;
>> >> +
>> >> + /*
>> >> + * moving data is expensive, so let's only do that if
>> >> + * there's substantial gain (at least BIG_CHUNK_GAP chunks)
>> >> + */
>> >> + if (zhdr->first_chunks != 0 && zhdr->last_chunks == 0 &&
>> >> + zhdr->start_middle - (zhdr->first_chunks + ZHDR_CHUNKS) >=
>> >> + BIG_CHUNK_GAP) {
>> >> + mchunk_memmove(zhdr, zhdr->first_chunks + 1);
>> >> + zhdr->start_middle = zhdr->first_chunks + 1;
>> >
>> > this should be first_chunks + ZHDR_CHUNKS, not + 1.
>> >
>> >> + return 1;
>> >> + } else if (zhdr->last_chunks != 0 && zhdr->first_chunks == 0 &&
>> >> + TOTAL_CHUNKS - (zhdr->last_chunks + zhdr->start_middle
>> >> + + zhdr->middle_chunks) >=
>> >> + BIG_CHUNK_GAP) {
>> >> + unsigned short new_start = NCHUNKS - zhdr->last_chunks -
>> >
>> > this should be TOTAL_CHUNKS, not NCHUNKS.
>>
>> Right :/
>
> So here we go:
>
>
> z3fold_compact_page() currently only handles the situation when
> there's a single middle chunk within the z3fold page. However it
> may be worth it to move middle chunk closer to either first or
> last chunk, whichever is there, if the gap between them is big
> enough.
>
> This patch adds the relevant code, using BIG_CHUNK_GAP define as
> a threshold for middle chunk to be worth moving.
>
> Signed-off-by: Vitaly Wool <vitalywool@gmail.com>
Acked-by: Dan Streetman <ddstreet@ieee.org>
> ---
> mm/z3fold.c | 26 +++++++++++++++++++++++++-
> 1 file changed, 25 insertions(+), 1 deletion(-)
>
> diff --git a/mm/z3fold.c b/mm/z3fold.c
> index 98ab01f..fca3310 100644
> --- a/mm/z3fold.c
> +++ b/mm/z3fold.c
> @@ -268,6 +268,7 @@ static inline void *mchunk_memmove(struct z3fold_header *zhdr,
> zhdr->middle_chunks << CHUNK_SHIFT);
> }
>
> +#define BIG_CHUNK_GAP 3
> /* Has to be called with lock held */
> static int z3fold_compact_page(struct z3fold_header *zhdr)
> {
> @@ -286,8 +287,31 @@ static int z3fold_compact_page(struct z3fold_header *zhdr)
> zhdr->middle_chunks = 0;
> zhdr->start_middle = 0;
> zhdr->first_num++;
> + return 1;
> }
> - return 1;
> +
> + /*
> + * moving data is expensive, so let's only do that if
> + * there's substantial gain (at least BIG_CHUNK_GAP chunks)
> + */
> + if (zhdr->first_chunks != 0 && zhdr->last_chunks == 0 &&
> + zhdr->start_middle - (zhdr->first_chunks + ZHDR_CHUNKS) >=
> + BIG_CHUNK_GAP) {
> + mchunk_memmove(zhdr, zhdr->first_chunks + ZHDR_CHUNKS);
> + zhdr->start_middle = zhdr->first_chunks + ZHDR_CHUNKS;
> + return 1;
> + } else if (zhdr->last_chunks != 0 && zhdr->first_chunks == 0 &&
> + TOTAL_CHUNKS - (zhdr->last_chunks + zhdr->start_middle
> + + zhdr->middle_chunks) >=
> + BIG_CHUNK_GAP) {
> + unsigned short new_start = TOTAL_CHUNKS - zhdr->last_chunks -
> + zhdr->middle_chunks;
> + mchunk_memmove(zhdr, new_start);
> + zhdr->start_middle = new_start;
> + return 1;
> + }
> +
> + return 0;
> }
>
> /**
> --
> 2.4.2
[toc] | [prev] | [standalone]
Back to top | Article view | linux.kernel
csiph-web