Skip to contentSkip to conversation

migration/postcopy: simplify postcopy_chunk_hostpages_pass

PATCH In review Wei Yang 2 participants 7 messages Aug 6, 2019 – Aug 7, 2019

lore
Share & tools
lore

Wei Yang

author
#0 lore raw

cover migration/postcopy: simplify postcopy_chunk_hostpages_pass

When looking into function postcopy_chunk_hostpages_pass(), we could use alignment calculation to simplify it.

Wei Yang (2):
migration/postcopy: simplify calculation of run_start and
fixup_start_addr
migration/postcopy: use QEMU_IS_ALIGNED to replace host_offset

 migration/ram.c | 37 +++++++------------------------------
 1 file changed, 7 insertions(+), 30 deletions(-)
Signature · 1 line
2.17.1
author
#1 lore raw

PATCH 1/2 migration/postcopy: simplify calculation of run_start and fixup_start_addr

The purpose of the calculation is to find a HostPage which is partially dirty.

* fixup_start_addr points to the start of the HostPage to discard
* run_start points to the next HostPage to check

While in the middle stage, there would two cases for run_start:

* aligned with HostPage means this is not partially dirty
* not aligned means this is partially dirty

When it is aligned, no work and calculation is necessary. run_start already points to the start of next HostPage and is ready to continue.

When it is not aligned, the calculation could be simplified with:

* fixup_start_addr = QEMU_ALIGN_DOWN(run_start, host_ratio)
* run_start = QEMU_ALIGN_UP(run_start, host_ratio)

By doing so, run_start always points to the next HostPage to check. fixup_start_addr always points to the HostPage to discard.

---
 migration/ram.c | 34 +++++++---------------------------
 1 file changed, 7 insertions(+), 27 deletions(-)
migration/ram.c +7 -27
index c9585487ac..d86661a015 100644
@@ -2956,7 +2956,6 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,
     }
 
     while (run_start < pages) {
-        unsigned long fixup_start_addr;
         unsigned long host_offset;
 
         /*
@@ -2964,45 +2963,26 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,
          * page, then we need to fixup this host page.
          */
         host_offset = run_start % host_ratio;
-        if (host_offset) {
-            fixup_start_addr = run_start - host_offset;
-            /*
-             * This host page has gone, the next loop iteration starts
-             * from after the fixup
-             */
-            run_start = fixup_start_addr + host_ratio;
-        } else {
+        if (!host_offset) {
             /* Find the end of this run */
-            unsigned long run_end;
             if (unsent_pass) {
-                run_end = find_next_bit(unsentmap, pages, run_start + 1);
+                run_start = find_next_bit(unsentmap, pages, run_start + 1);
             } else {
-                run_end = find_next_zero_bit(bitmap, pages, run_start + 1);
+                run_start = find_next_zero_bit(bitmap, pages, run_start + 1);
             }
             /*
              * If the end isn't at the start of a host page, then the
              * run doesn't finish at the end of a host page
              * and we need to discard.
              */
-            host_offset = run_end % host_ratio;
-            if (host_offset) {
-                fixup_start_addr = run_end - host_offset;
-                /*
-                 * This host page has gone, the next loop iteration starts
-                 * from after the fixup
-                 */
-                run_start = fixup_start_addr + host_ratio;
-            } else {
-                /*
-                 * No discards on this iteration, next loop starts from
-                 * next sent/dirty page
-                 */
-                run_start = run_end + 1;
-            }
+            host_offset = run_start % host_ratio;
         }
 
         if (host_offset) {
             unsigned long page;
+            unsigned long fixup_start_addr = QEMU_ALIGN_DOWN(run_start,
+                                                             host_ratio);
+            run_start = QEMU_ALIGN_UP(run_start, host_ratio);
 
             /* Tell the destination to discard this page */
             if (unsent_pass || !test_bit(fixup_start_addr, unsentmap)) {
Signature · 1 line
2.17.1
Reviewed-by on v1 1/2
#2 lore raw

Re: [Qemu-devel] [PATCH 1/2] migration/postcopy: simplify calculation of run_start and fixup_start_addr

Quoted 16 lines · * Wei Yang ([email protected]) wrote:

The purpose of the calculation is to find a HostPage which is partially dirty.

* fixup_start_addr points to the start of the HostPage to discard
* run_start points to the next HostPage to check

While in the middle stage, there would two cases for run_start:

* aligned with HostPage means this is not partially dirty
* not aligned means this is partially dirty

When it is aligned, no work and calculation is necessary. run_start already points to the start of next HostPage and is ready to continue.

When it is not aligned, the calculation could be simplified with:

Quoted 7 lines

* fixup_start_addr = QEMU_ALIGN_DOWN(run_start, host_ratio)
* run_start = QEMU_ALIGN_UP(run_start, host_ratio)

By doing so, run_start always points to the next HostPage to check. fixup_start_addr always points to the HostPage to discard.

Yes that's a lot shorter; note it doess it on top of your cleanup from a couple of weeks back.

Quoted 72 lines
---
 migration/ram.c | 34 +++++++---------------------------
 1 file changed, 7 insertions(+), 27 deletions(-)
migration/ram.c +7 -27
index c9585487ac..d86661a015 100644
@@ -2956,7 +2956,6 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,
     }
 
     while (run_start < pages) {
-        unsigned long fixup_start_addr;
         unsigned long host_offset;
 
         /*
@@ -2964,45 +2963,26 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,
          * page, then we need to fixup this host page.
          */
         host_offset = run_start % host_ratio;
-        if (host_offset) {
-            fixup_start_addr = run_start - host_offset;
-            /*
-             * This host page has gone, the next loop iteration starts
-             * from after the fixup
-             */
-            run_start = fixup_start_addr + host_ratio;
-        } else {
+        if (!host_offset) {
             /* Find the end of this run */
-            unsigned long run_end;
             if (unsent_pass) {
-                run_end = find_next_bit(unsentmap, pages, run_start + 1);
+                run_start = find_next_bit(unsentmap, pages, run_start + 1);
             } else {
-                run_end = find_next_zero_bit(bitmap, pages, run_start + 1);
+                run_start = find_next_zero_bit(bitmap, pages, run_start + 1);
             }
             /*
              * If the end isn't at the start of a host page, then the
              * run doesn't finish at the end of a host page
              * and we need to discard.
              */
-            host_offset = run_end % host_ratio;
-            if (host_offset) {
-                fixup_start_addr = run_end - host_offset;
-                /*
-                 * This host page has gone, the next loop iteration starts
-                 * from after the fixup
-                 */
-                run_start = fixup_start_addr + host_ratio;
-            } else {
-                /*
-                 * No discards on this iteration, next loop starts from
-                 * next sent/dirty page
-                 */
-                run_start = run_end + 1;
-            }
+            host_offset = run_start % host_ratio;
         }
 
         if (host_offset) {
             unsigned long page;
+            unsigned long fixup_start_addr = QEMU_ALIGN_DOWN(run_start,
+                                                             host_ratio);
+            run_start = QEMU_ALIGN_UP(run_start, host_ratio);
 
             /* Tell the destination to discard this page */
             if (unsent_pass || !test_bit(fixup_start_addr, unsentmap)) {
Signature · 1 line
2.17.1

--
Dr. David Alan Gilbert / [email protected] / Manchester, UK

author
#3 lore raw

Re: [Qemu-devel] [PATCH 1/2] migration/postcopy: simplify calculation of run_start and fixup_start_addr

Quoted 20 lines · Dr. David Alan Gilbert
Quoted 19 lines · * Wei Yang ([email protected]) wrote:

The purpose of the calculation is to find a HostPage which is partially dirty.

* fixup_start_addr points to the start of the HostPage to discard
* run_start points to the next HostPage to check

While in the middle stage, there would two cases for run_start:

* aligned with HostPage means this is not partially dirty
* not aligned means this is partially dirty

When it is aligned, no work and calculation is necessary. run_start already points to the start of next HostPage and is ready to continue.

When it is not aligned, the calculation could be simplified with:

* fixup_start_addr = QEMU_ALIGN_DOWN(run_start, host_ratio)
* run_start = QEMU_ALIGN_UP(run_start, host_ratio)

Quoted 8 lines
Quoted 4 lines

By doing so, run_start always points to the next HostPage to check. fixup_start_addr always points to the HostPage to discard.

Yes that's a lot shorter; note it doess it on top of your cleanup from a couple of weeks back.

You are right, I forget to mention it :-)

Quoted 77 lines
Quoted 72 lines
---
 migration/ram.c | 34 +++++++---------------------------
 1 file changed, 7 insertions(+), 27 deletions(-)
migration/ram.c +7 -27
index c9585487ac..d86661a015 100644
@@ -2956,7 +2956,6 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,
     }
 
     while (run_start < pages) {
-        unsigned long fixup_start_addr;
         unsigned long host_offset;
 
         /*
@@ -2964,45 +2963,26 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,
          * page, then we need to fixup this host page.
          */
         host_offset = run_start % host_ratio;
-        if (host_offset) {
-            fixup_start_addr = run_start - host_offset;
-            /*
-             * This host page has gone, the next loop iteration starts
-             * from after the fixup
-             */
-            run_start = fixup_start_addr + host_ratio;
-        } else {
+        if (!host_offset) {
             /* Find the end of this run */
-            unsigned long run_end;
             if (unsent_pass) {
-                run_end = find_next_bit(unsentmap, pages, run_start + 1);
+                run_start = find_next_bit(unsentmap, pages, run_start + 1);
             } else {
-                run_end = find_next_zero_bit(bitmap, pages, run_start + 1);
+                run_start = find_next_zero_bit(bitmap, pages, run_start + 1);
             }
             /*
              * If the end isn't at the start of a host page, then the
              * run doesn't finish at the end of a host page
              * and we need to discard.
              */
-            host_offset = run_end % host_ratio;
-            if (host_offset) {
-                fixup_start_addr = run_end - host_offset;
-                /*
-                 * This host page has gone, the next loop iteration starts
-                 * from after the fixup
-                 */
-                run_start = fixup_start_addr + host_ratio;
-            } else {
-                /*
-                 * No discards on this iteration, next loop starts from
-                 * next sent/dirty page
-                 */
-                run_start = run_end + 1;
-            }
+            host_offset = run_start % host_ratio;
         }
 
         if (host_offset) {
             unsigned long page;
+            unsigned long fixup_start_addr = QEMU_ALIGN_DOWN(run_start,
+                                                             host_ratio);
+            run_start = QEMU_ALIGN_UP(run_start, host_ratio);
 
             /* Tell the destination to discard this page */
             if (unsent_pass || !test_bit(fixup_start_addr, unsentmap)) {
Signature · 1 line
2.17.1

--
Dr. David Alan Gilbert / [email protected] / Manchester, UK

Signature · 2 lines
Wei Yang
Help you, Help me
author
#4 lore raw

PATCH 2/2 migration/postcopy: use QEMU_IS_ALIGNED to replace host_offset

In reply to Wei Yang

Use QEMU_IS_ALIGNED for the check, it would be more consistent with other align calculations.

---
 migration/ram.c | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)
migration/ram.c +2 -5
index d86661a015..dfbf71c580 100644
@@ -2956,14 +2956,12 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,
     }
 
     while (run_start < pages) {
-        unsigned long host_offset;
 
         /*
          * If the start of this run of pages is in the middle of a host
          * page, then we need to fixup this host page.
          */
-        host_offset = run_start % host_ratio;
-        if (!host_offset) {
+        if (QEMU_IS_ALIGNED(run_start, host_ratio)) {
             /* Find the end of this run */
             if (unsent_pass) {
                 run_start = find_next_bit(unsentmap, pages, run_start + 1);
@@ -2975,10 +2973,9 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,
              * run doesn't finish at the end of a host page
              * and we need to discard.
              */
-            host_offset = run_start % host_ratio;
         }
 
-        if (host_offset) {
+        if (!QEMU_IS_ALIGNED(run_start, host_ratio)) {
             unsigned long page;
             unsigned long fixup_start_addr = QEMU_ALIGN_DOWN(run_start,
                                                              host_ratio);
Signature · 1 line
2.17.1
Reviewed-by on v1 2/2
#5 lore raw

Re: [Qemu-devel] [PATCH 2/2] migration/postcopy: use QEMU_IS_ALIGNED to replace host_offset

Quoted 4 lines · * Wei Yang ([email protected]) wrote:

Use QEMU_IS_ALIGNED for the check, it would be more consistent with other align calculations.

Quoted 39 lines
---
 migration/ram.c | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)
migration/ram.c +2 -5
index d86661a015..dfbf71c580 100644
@@ -2956,14 +2956,12 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,
     }
 
     while (run_start < pages) {
-        unsigned long host_offset;
 
         /*
          * If the start of this run of pages is in the middle of a host
          * page, then we need to fixup this host page.
          */
-        host_offset = run_start % host_ratio;
-        if (!host_offset) {
+        if (QEMU_IS_ALIGNED(run_start, host_ratio)) {
             /* Find the end of this run */
             if (unsent_pass) {
                 run_start = find_next_bit(unsentmap, pages, run_start + 1);
@@ -2975,10 +2973,9 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,
              * run doesn't finish at the end of a host page
              * and we need to discard.
              */
-            host_offset = run_start % host_ratio;
         }
 
-        if (host_offset) {
+        if (!QEMU_IS_ALIGNED(run_start, host_ratio)) {
             unsigned long page;
             unsigned long fixup_start_addr = QEMU_ALIGN_DOWN(run_start,
                                                              host_ratio);
Signature · 1 line
2.17.1

--
Dr. David Alan Gilbert / [email protected] / Manchester, UK

#6 lore raw
In reply to Wei Yang
Quoted 10 lines · * Wei Yang ([email protected]) wrote:

When looking into function postcopy_chunk_hostpages_pass(), we could use alignment calculation to simplify it.

Wei Yang (2):
migration/postcopy: simplify calculation of run_start and
fixup_start_addr
migration/postcopy: use QEMU_IS_ALIGNED to replace host_offset

 migration/ram.c | 37 +++++++------------------------------
 1 file changed, 7 insertions(+), 30 deletions(-)

Queued

Quoted 4 lines
Signature · 1 line
2.17.1

--
Dr. David Alan Gilbert / [email protected] / Manchester, UK