migration/ram.c: Refactor compress code
v2 cover migration/ram.c: Refactor compress code
This series refactors the ram compress code.
It first removes ram.c dependencies from the core compress code, then moves it out to its own file. Finally, on the migration destination side the initialisation and cleanup of compress threads is moved out of ram.c to migration.c. This allows using COLO with compress enabled.
Changes since v1:
- Add postcopy tests with compress enabled
- Use page_size variable in "ram-compress.c: Make target independent"
- Squash "ram.c: Remove unused include after moving out code" with "ram.c: Move core compression code into its own file"
- Add Reviewed-by: Tags
Lukas Straub (13):
qtest/migration-test.c: Add postcopy tests with compress enabled ram.c: Let the compress threads return a CompressResult enum ram.c: Dont change param->block in the compress thread ram.c: Reset result after sending queued data
ram.c: Do not call save_page_header() from compress threads ram.c: Call update_compress_thread_counts from
compress_send_queued_data
ram.c: Remove last ram.c dependency from the core compress code ram.c: Introduce whitespace (squash with next patch) ram.c: Move core compression code into its own file ram.c: Remove whitespace (squash with previous patch) ram.c: Move core decompression code into its own file ram compress: Assert that the file buffer matches the result ram-compress.c: Make target independent
migration/meson.build | 5 +- migration/qemu-file.c | 11 + migration/qemu-file.h | 1 + migration/ram-compress.c | 484 ++++++++++++++++++++++++++++++++++ migration/ram-compress.h | 70 +++++ migration/ram.c | 485 +++-------------------------------- tests/qtest/migration-test.c | 83 +++--- 7 files changed, 660 insertions(+), 479 deletions(-) create mode 100644 migration/ram-compress.c create mode 100644 migration/ram-compress.h
--
2.40.0
PATCH v2 1/13 qtest/migration-test.c: Add postcopy tests with compress enabled
Add postcopy tests with compress enabled to ensure nothing breaks with the refactoring in the next commits.
preempt+compress is blocked, so no test needed for that case.
--- tests/qtest/migration-test.c | 83 +++++++++++++++++++++++------------- 1 file changed, 53 insertions(+), 30 deletions(-)
tests/qtest/migration-test.c +53 -30
@@ -1127,6 +1127,36 @@ test_migrate_tls_x509_finish(QTestState *from,#endif /* CONFIG_TASN1 */ #endif /* CONFIG_GNUTLS */ +static void * +test_migrate_compress_start (QTestState *from, +QTestState *to) +{ +migrate_set_parameter_int (from,"compress-level" ,1 ); +migrate_set_parameter_int (from,"compress-threads" ,4 ); +migrate_set_parameter_bool (from,"compress-wait-thread" , true); +migrate_set_parameter_int (to,"decompress-threads" ,4 ); + +migrate_set_capability (from,"compress" , true); +migrate_set_capability (to,"compress" , true); + +return NULL ; +} + +static void * +test_migrate_compress_nowait_start (QTestState *from, +QTestState *to) +{ +migrate_set_parameter_int (from,"compress-level" ,9 ); +migrate_set_parameter_int (from,"compress-threads" ,1 ); +migrate_set_parameter_bool (from,"compress-wait-thread" , false); +migrate_set_parameter_int (to,"decompress-threads" ,1 ); + +migrate_set_capability (from,"compress" , true); +migrate_set_capability (to,"compress" , true); + +return NULL ; +} +static int migrate_postcopy_prepare (QTestState **from_ptr,QTestState **to_ptr,MigrateCommon *args)
@@ -1204,6 +1234,15 @@ static void test_postcopy(void)test_postcopy_common (&args); } +static void test_postcopy_compress (void ) +{ +MigrateCommon args = { + .start_hook = test_migrate_compress_start + }; + +test_postcopy_common (&args); +} +static void test_postcopy_preempt (void ) {MigrateCommon args = {
@@ -1305,6 +1344,15 @@ static void test_postcopy_recovery(void)test_postcopy_recovery_common (&args); } +static void test_postcopy_recovery_compress (void ) +{ +MigrateCommon args = { + .start_hook = test_migrate_compress_start + }; + +test_postcopy_recovery_common (&args); +} +#ifdef CONFIG_GNUTLS static void test_postcopy_recovery_tls_psk (void ) {
@@ -1338,6 +1386,7 @@ static void test_postcopy_preempt_all(void) test_postcopy_recovery_common(&args); } +#endif static void test_baddest (void )
@@ -1559,21 +1608,6 @@ static void test_precopy_unix_xbzrle(void)test_precopy_common (&args); } -static void * -test_migrate_compress_start (QTestState *from, -QTestState *to) -{ -migrate_set_parameter_int (from,"compress-level" ,1 ); -migrate_set_parameter_int (from,"compress-threads" ,4 ); -migrate_set_parameter_bool (from,"compress-wait-thread" , true); -migrate_set_parameter_int (to,"decompress-threads" ,4 ); - -migrate_set_capability (from,"compress" , true); -migrate_set_capability (to,"compress" , true); - -return NULL ; -} -static void test_precopy_unix_compress (void ) { g_autofree char *uri = g_strdup_printf("unix:%s/migsocket", tmpfs);
@@ -1591,21 +1625,6 @@ static void test_precopy_unix_compress(void)test_precopy_common (&args); } -static void * -test_migrate_compress_nowait_start (QTestState *from, -QTestState *to) -{ -migrate_set_parameter_int (from,"compress-level" ,9 ); -migrate_set_parameter_int (from,"compress-threads" ,1 ); -migrate_set_parameter_bool (from,"compress-wait-thread" , false); -migrate_set_parameter_int (to,"decompress-threads" ,1 ); - -migrate_set_capability (from,"compress" , true); -migrate_set_capability (to,"compress" , true); - -return NULL ; -} -static void test_precopy_unix_compress_nowait (void ) { g_autofree char *uri = g_strdup_printf("unix:%s/migsocket", tmpfs);
@@ -2604,8 +2623,12 @@ int main(int argc, char **argv)if (has_uffd) {qtest_add_func ("/migration/postcopy/plain" , test_postcopy); +qtest_add_func ("/migration/postcopy/compress/plain" , + test_postcopy_compress);qtest_add_func ("/migration/postcopy/recovery/plain" , test_postcopy_recovery); +qtest_add_func ("/migration/postcopy/recovery/compress/plain" , + test_postcopy_recovery_compress);qtest_add_func ("/migration/postcopy/preempt/plain" , test_postcopy_preempt);qtest_add_func ("/migration/postcopy/preempt/recovery/plain" , test_postcopy_preempt_recovery);
--
2.40.0
Re: [PATCH v2 01/13] qtest/migration-test.c: Add postcopy tests with compress enabled
Quoted 6 lines · Lukas Straub
Add postcopy tests with compress enabled to ensure nothing breaks with the refactoring in the next commits.
preempt+compress is blocked, so no test needed for that case.
Signed-off-by Lukas Straub <[email protected]>
And I wanted to removed the old compression code and it gets new users. Sniff.
Quoted 16 lines
--- tests/qtest/migration-test.c | 83 +++++++++++++++++++++++------------- 1 file changed, 53 insertions(+), 30 deletions(-)tests/qtest/migration-test.c +4
-0@@ -1127,6 +1127,36 @@ test_migrate_tls_x509_finish(QTestState *from,#endif /* CONFIG_TASN1 */ #endif /* CONFIG_GNUTLS */ +static void * +test_migrate_compress_start (QTestState *from, +QTestState *to) +{
tests/qtest/migration-test.c test_migrate_tls_x509_finish(QTestState *from, · line 1143
Quoted 10 lines
tests/qtest/migration-test.c +10
-0+migrate_set_parameter_int (from,"compress-level" ,1 ); +migrate_set_parameter_int (from,"compress-threads" ,4 ); +migrate_set_parameter_bool (from,"compress-wait-thread" , true); +migrate_set_parameter_int (to,"decompress-threads" ,4 ); + +migrate_set_capability (from,"compress" , true); +migrate_set_capability (to,"compress" , true); + +return NULL ; +}
Independently of this patch, we need to change this test to use 4 compression tests and 3 decompression or anything that is not the same number in both sides.
I was complaining about this and when I arrived to the end of the path found that this was code movement.
Later, Juan.
Re: [PATCH v2 01/13] qtest/migration-test.c: Add postcopy tests with compress enabled
Quoted 11 lines · On Thu, 20 Apr 2023 12:20:25 +0200 Juan Quintela <[email protected]> wrote:
Quoted 6 lines · Lukas Straub
Add postcopy tests with compress enabled to ensure nothing breaks with the refactoring in the next commits.
preempt+compress is blocked, so no test needed for that case.
Signed-off-by Lukas Straub <[email protected]>Reviewed-by Juan Quintela <[email protected]>And I wanted to removed the old compression code and it gets new users. Sniff.
Who know how many compress threads users are out there...
By the way, I'm not against deprecating compress threads in the long run. I'm already working on (cleanly :)) adding colo support with multifd.
Quoted 31 lines
Quoted 16 lines
--- tests/qtest/migration-test.c | 83 +++++++++++++++++++++++------------- 1 file changed, 53 insertions(+), 30 deletions(-)tests/qtest/migration-test.c +4
-0@@ -1127,6 +1127,36 @@ test_migrate_tls_x509_finish(QTestState *from,#endif /* CONFIG_TASN1 */ #endif /* CONFIG_GNUTLS */ +static void * +test_migrate_compress_start (QTestState *from, +QTestState *to) +{tests/qtest/migration-test.c test_migrate_tls_x509_finish(QTestState *from, · line 1143
Quoted 10 lines
tests/qtest/migration-test.c +10
-0+migrate_set_parameter_int (from,"compress-level" ,1 ); +migrate_set_parameter_int (from,"compress-threads" ,4 ); +migrate_set_parameter_bool (from,"compress-wait-thread" , true); +migrate_set_parameter_int (to,"decompress-threads" ,4 ); + +migrate_set_capability (from,"compress" , true); +migrate_set_capability (to,"compress" , true); + +return NULL ; +}Independently of this patch, we need to change this test to use 4 compression tests and 3 decompression or anything that is not the same number in both sides.
Quoted 5 lines
I was complaining about this and when I arrived to the end of the path found that this was code movement.
Later, Juan.
Oops, forgot to mention, the test is based on this patch
https://lore.kernel.org/qemu-devel/2f4abb67cf5f3e1591b2666676462a93bdd20bbc.1680618040.git.lukasstraub2@web.de/
Will probably carry the patch with this series then. So you mean 4 compress _threads_ and 3 decompress _threads_?
Re: [PATCH v2 01/13] qtest/migration-test.c: Add postcopy tests with compress enabled
Quoted 9 lines · Lukas Straub
Quoted 6 lines · On Thu, 20 Apr 2023 12:20:25 +0200 Juan Quintela <[email protected]> wrote:
Quoted 5 lines · Lukas Straub
Add postcopy tests with compress enabled to ensure nothing breaks with the refactoring in the next commits.
preempt+compress is blocked, so no test needed for that case.
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
Signed-off-by Lukas Straub <[email protected]>Reviewed-by Juan Quintela <[email protected]>And I wanted to removed the old compression code and it gets new users. Sniff.
Who know how many compress threads users are out there...
Not too much.
We broke it during development and nobody found it.
And the reason that I wrote the multifd-zlib compression code was because I was not able to get a migration-test working with compression, so ....
Quoted 3 lines
By the way, I'm not against deprecating compress threads in the long run. I'm already working on (cleanly :)) adding colo support with multifd.
Ok, then I will still put the deprecate comment there.
Quoted 34 lines
Quoted 34 lines
Quoted 16 lines
--- tests/qtest/migration-test.c | 83 +++++++++++++++++++++++------------- 1 file changed, 53 insertions(+), 30 deletions(-)tests/qtest/migration-test.c +4
-0@@ -1127,6 +1127,36 @@ test_migrate_tls_x509_finish(QTestState *from,#endif /* CONFIG_TASN1 */ #endif /* CONFIG_GNUTLS */ +static void * +test_migrate_compress_start (QTestState *from, +QTestState *to) +{tests/qtest/migration-test.c test_migrate_tls_x509_finish(QTestState *from, · line 1143
Quoted 10 lines
tests/qtest/migration-test.c +10
-0+migrate_set_parameter_int (from,"compress-level" ,1 ); +migrate_set_parameter_int (from,"compress-threads" ,4 ); +migrate_set_parameter_bool (from,"compress-wait-thread" , true); +migrate_set_parameter_int (to,"decompress-threads" ,4 ); + +migrate_set_capability (from,"compress" , true); +migrate_set_capability (to,"compress" , true); + +return NULL ; +}Independently of this patch, we need to change this test to use 4 compression tests and 3 decompression or anything that is not the same number in both sides.
I was complaining about this and when I arrived to the end of the path found that this was code movement.
Quoted 8 lines
Quoted 2 lines
Later, Juan.
Oops, forgot to mention, the test is based on this patch
https://lore.kernel.org/qemu-devel/2f4abb67cf5f3e1591b2666676462a93bdd20bbc.1680618040.git.lukasstraub2@web.de/Will probably carry the patch with this series then. So you mean 4 compress _threads_ and 3 decompress _threads_?
Yeap.
Later, Juan.
PATCH v2 2/13 ram.c: Let the compress threads return a CompressResult enum
In reply to Lukas StraubThis will be used in the next commits to move save_page_header() out of compress code.
--- migration/ram.c | 34 ++++++++++++++++++++++------------ 1 file changed, 22 insertions(+), 12 deletions(-)
migration/ram.c +22 -12
@@ -493,10 +493,17 @@ MigrationOps *migration_ops;CompressionStats compression_counters; +enum CompressResult { +RES_NONE =0 , +RES_ZEROPAGE =1 , +RES_COMPRESS =2 +}; +typedef enum CompressResult CompressResult ; +struct CompressParam {bool done;bool quit; -bool zero_page; +CompressResult result;QEMUFile *file;QemuMutex mutex;QemuCond cond;
@@ -538,8 +545,9 @@ static QemuCond decomp_done_cond;static int ram_save_host_page_urgent (PageSearchStatus *pss); -static bool do_compress_ram_page (QEMUFile *f,z_stream *stream,RAMBlock *block, -ram_addr_t offset,uint8_t *source_buf); +static CompressResult do_compress_ram_page (QEMUFile *f,z_stream *stream, +RAMBlock *block,ram_addr_t offset, +uint8_t *source_buf);/* NOTE: page is the PFN not real ram_addr_t. */ static void pss_init (PageSearchStatus *pss,RAMBlock *rb,ram_addr_t page)
@@ -564,7 +572,7 @@ static void *do_data_compress(void *opaque)CompressParam *param = opaque;RAMBlock *block;ram_addr_t offset; -bool zero_page; +CompressResult result;qemu_mutex_lock (¶m->mutex);while (!param->quit) {
@@ -574,12 +582,12 @@ static void *do_data_compress(void *opaque) param->block =NULL ;qemu_mutex_unlock (¶m->mutex); - zero_page =do_compress_ram_page (param->file, ¶m->stream, - block, offset, param->originbuf); + result =do_compress_ram_page (param->file, ¶m->stream, + block, offset, param->originbuf);qemu_mutex_lock (&comp_done_lock); param->done = true; - param->zero_page = zero_page; + param->result = result;qemu_cond_signal (&comp_done_cond);qemu_mutex_unlock (&comp_done_lock);
@@ -1463,8 +1471,9 @@ static int ram_save_multifd_page(QEMUFile *file, RAMBlock *block,return 1 ; } -static bool do_compress_ram_page (QEMUFile *f,z_stream *stream,RAMBlock *block, -ram_addr_t offset,uint8_t *source_buf) +static CompressResult do_compress_ram_page (QEMUFile *f,z_stream *stream, +RAMBlock *block,ram_addr_t offset, +uint8_t *source_buf) {RAMState *rs = ram_state;PageSearchStatus *pss = &rs->pss[RAM_CHANNEL_PRECOPY ];
@@ -1472,7 +1481,7 @@ static bool do_compress_ram_page(QEMUFile *f, z_stream *stream, RAMBlock *block,int ret;if (save_zero_page_to_file (pss, f, block, offset)) { -return true; +return RES_ZEROPAGE ; }save_page_header (pss, f, block, offset |RAM_SAVE_FLAG_COMPRESS_PAGE );
@@ -1487,8 +1496,9 @@ static bool do_compress_ram_page(QEMUFile *f, z_stream *stream, RAMBlock *block,if (ret <0 ) {qemu_file_set_error (migrate_get_current ()->to_dst_file, ret);error_report ("compressed data failed!" ); +return RES_NONE ; } -return false; +return RES_COMPRESS ; } static void
@@ -1496,7 +1506,7 @@ update_compress_thread_counts(const CompressParam *param, int bytes_xmit) {ram_transferred_add (bytes_xmit); -if (param->zero_page) { +if (param->result ==RES_ZEROPAGE ) {stat64_add (&ram_atomic_counters.duplicate,1 );return ; }
--
2.40.0
Re: [PATCH v2 02/13] ram.c: Let the compress threads return a CompressResult enum
Quoted 4 lines · Lukas Straub
This will be used in the next commits to move
save_page_header()out of compress code.Signed-off-by Lukas Straub <[email protected]>
PATCH v2 3/13 ram.c: Dont change param->block in the compress thread
In reply to Lukas StraubInstead introduce a extra parameter to trigger the compress thread. Now, when the compress thread is done, we know what RAMBlock and offset it did compress.
This will be used in the next commits to move save_page_header() out of compress code.
--- migration/ram.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
migration/ram.c +4 -2
@@ -503,6 +503,7 @@ typedef enum CompressResult CompressResult;struct CompressParam {bool done;bool quit; +bool trigger;CompressResult result;QEMUFile *file;QemuMutex mutex;
@@ -576,10 +577,10 @@ static void *do_data_compress(void *opaque)qemu_mutex_lock (¶m->mutex);while (!param->quit) { -if (param->block) { +if (param->trigger) { block = param->block; offset = param->offset; - param->block =NULL ; + param->trigger = false;qemu_mutex_unlock (¶m->mutex); result = do_compress_ram_page(param->file, ¶m->stream,
@@ -1556,6 +1557,7 @@ static inline void set_compress_params(CompressParam *param, RAMBlock *block, { param->block = block; param->offset = offset; + param->trigger = true; }static int compress_page_with_multi_thread (RAMBlock *block,ram_addr_t offset)
--
2.40.0
Re: [PATCH v2 03/13] ram.c: Dont change param->block in the compress thread
Quoted 8 lines · Lukas Straub
Instead introduce a extra parameter to trigger the compress thread. Now, when the compress thread is done, we know what RAMBlock and offset it did compress.
This will be used in the next commits to move
save_page_header()out of compress code.Signed-off-by Lukas Straub <[email protected]>
Much better, thanks.
PATCH v2 4/13 ram.c: Reset result after sending queued data
In reply to Lukas StraubAnd take the param->mutex lock for the whole section to ensure thread-safety.
Now, it is explicitly clear if there is no queued data to send. Before, this was handled by param->file stream being empty and thus qemu_put_qemu_file() not sending anything.
This will be used in the next commits to move save_page_header() out of compress code.
--- migration/ram.c | 32 ++++++++++++++++++++++---------- 1 file changed, 22 insertions(+), 10 deletions(-)
migration/ram.c +22 -10
@@ -1519,6 +1519,13 @@ update_compress_thread_counts(const CompressParam *param, int bytes_xmit)static bool save_page_use_compression (RAMState *rs); +static inline void compress_reset_result (CompressParam *param) +{ + param->result =RES_NONE ; + param->block =NULL ; + param->offset =0 ; +} +static void flush_compressed_data (RAMState *rs) {MigrationState *ms =migrate_get_current ();
@@ -1540,13 +1547,16 @@ static void flush_compressed_data(RAMState *rs)for (idx =0 ; idx < thread_count; idx++) {qemu_mutex_lock (&comp_param[idx].mutex);if (!comp_param[idx].quit) { - len =qemu_put_qemu_file (ms->to_dst_file, comp_param[idx].file); +CompressParam *param = &comp_param[idx]; + len =qemu_put_qemu_file (ms->to_dst_file, param->file); +compress_reset_result (param); +/* * it's safe to fetch zero_page without holding comp_done_lock * as there is no further request submitted to the thread, * i.e, the thread should be waiting for a request at this point. */ -update_compress_thread_counts (&comp_param[idx], len); +update_compress_thread_counts (param, len); }qemu_mutex_unlock (&comp_param[idx].mutex); }
@@ -1571,15 +1581,17 @@ static int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset) retry:for (idx =0 ; idx < thread_count; idx++) {if (comp_param[idx].done) { - comp_param[idx].done = false; - bytes_xmit =qemu_put_qemu_file (ms->to_dst_file, - comp_param[idx].file); -qemu_mutex_lock (&comp_param[idx].mutex); -set_compress_params (&comp_param[idx], block, offset); -qemu_cond_signal (&comp_param[idx].cond); -qemu_mutex_unlock (&comp_param[idx].mutex); +CompressParam *param = &comp_param[idx]; +qemu_mutex_lock (¶m->mutex); + param->done = false; + bytes_xmit =qemu_put_qemu_file (ms->to_dst_file, param->file); +compress_reset_result (param); +set_compress_params (param, block, offset); + +update_compress_thread_counts (param, bytes_xmit); +qemu_cond_signal (¶m->cond); +qemu_mutex_unlock (¶m->mutex); pages =1 ; -update_compress_thread_counts (&comp_param[idx], bytes_xmit);break ; } }
--
2.40.0
Re: [PATCH v2 04/13] ram.c: Reset result after sending queued data
Quoted 10 lines · Lukas Straub
And take the
param->mutexlock for the whole section to ensure thread-safety.
Now, it is explicitly clear if there is no queued data to send. Before, this was handled byparam->filestream being empty and thusqemu_put_qemu_file()not sending anything.This will be used in the next commits to move
save_page_header()out of compress code.Signed-off-by Lukas Straub <[email protected]>
If you do more changes around here, please consider:
Review static void flush_compressed_data(RAMState *rs) · line 1547
Quoted 2 lines
(quoted diff) +0
-0@@ -1540,13 +1547,16 @@ static void flush_compressed_data(RAMState *rs) for (idx = 0; idx < thread_count; idx++) {
Move
CompressParam *param = &comp_param[idx];
to here, and use it also for the locks.
I will even think about calling the variable just p.
And once there, everything under the sun except this uses i as a for variable, not idx O:-)
migration/ram.c static void flush_compressed_data(RAMState *rs) · line 1550
Quoted 4 lines
migration/ram.c +1
-1qemu_mutex_lock (&comp_param[idx].mutex);if (!comp_param[idx].quit) { - len =qemu_put_qemu_file (ms->to_dst_file, comp_param[idx].file); +CompressParam *param = &comp_param[idx];
Move this declaration
Quoted 14 lines
migration/ram.c +4
-1+ len =qemu_put_qemu_file (ms->to_dst_file, param->file); +compress_reset_result (param); +/* * it's safe to fetch zero_page without holding comp_done_lock * as there is no further request submitted to the thread, * i.e, the thread should be waiting for a request at this point. */ -update_compress_thread_counts (&comp_param[idx], len); +update_compress_thread_counts (param, len); }qemu_mutex_unlock (&comp_param[idx].mutex); }
migration/ram.c static int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset) · line 1574
Quoted 4 lines
migration/ram.c +0
-1@@ -1571,15 +1581,17 @@ static int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset) retry:for (idx =0 ; idx < thread_count; idx++) {if (comp_param[idx].done) { - comp_param[idx].done = false;
Same here.
PATCH v2 5/13 ram.c: Do not call save_page_header() from compress threads
In reply to Lukas Straubsave_page_header() accesses several global variables, so calling it from multiple threads is pretty ugly.
Instead, call save_page_header() before writing out the compressed data from the compress buffer to the migration stream.
This also makes the core compress code more independend from ram.c.
--- migration/ram.c | 44 +++++++++++++++++++++++++++++++++++--------- 1 file changed, 35 insertions(+), 9 deletions(-)
migration/ram.c +35 -9
@@ -1476,17 +1476,13 @@ static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream, RAMBlock *block, ram_addr_t offset, uint8_t *source_buf) { - RAMState *rs = ram_state; -PageSearchStatus *pss = &rs->pss[RAM_CHANNEL_PRECOPY ]; uint8_t *p = block->host + offset;int ret; -if (save_zero_page_to_file (pss, f, block, offset)) { +if (buffer_is_zero (p,TARGET_PAGE_SIZE )) {return RES_ZEROPAGE ; } -save_page_header (pss, f, block, offset |RAM_SAVE_FLAG_COMPRESS_PAGE ); -/* * copy it to a internal buffer to avoid it being modified by VM * so that we can catch up the error during compression and
@@ -1526,9 +1522,40 @@ static inline void compress_reset_result(CompressParam *param) param->offset =0 ; } -static void flush_compressed_data (RAMState *rs) +static int send_queued_data (CompressParam *param) { +PageSearchStatus *pss = &ram_state->pss[RAM_CHANNEL_PRECOPY ];MigrationState *ms =migrate_get_current (); +QEMUFile *file = ms->to_dst_file; +int len =0 ; + +RAMBlock *block = param->block; +ram_addr_t offset = param->offset; + +if (param->result ==RES_NONE ) { +return 0 ; + } + +assert (block == pss->last_sent_block); + +if (param->result ==RES_ZEROPAGE ) { + len +=save_page_header (pss, file, block, offset |RAM_SAVE_FLAG_ZERO ); +qemu_put_byte (file,0 ); + len +=1 ; +ram_release_page (block->idstr, offset); + }else if (param->result ==RES_COMPRESS ) { + len +=save_page_header (pss, file, block, + offset |RAM_SAVE_FLAG_COMPRESS_PAGE ); + len +=qemu_put_qemu_file (file, param->file); + }else { +abort (); + } + +return len; +} + +static void flush_compressed_data (RAMState *rs) +{int idx, len, thread_count;if (!save_page_use_compression (rs)) {
@@ -1548,7 +1575,7 @@ static void flush_compressed_data(RAMState *rs)qemu_mutex_lock (&comp_param[idx].mutex);if (!comp_param[idx].quit) {CompressParam *param = &comp_param[idx]; - len =qemu_put_qemu_file (ms->to_dst_file, param->file); + len =send_queued_data (param);compress_reset_result (param);/*
@@ -1574,7 +1601,6 @@ static int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset) {int idx, thread_count, bytes_xmit =-1 , pages =-1 ;bool wait =migrate_compress_wait_thread (); -MigrationState *ms =migrate_get_current (); thread_count =migrate_compress_threads ();qemu_mutex_lock (&comp_done_lock);
@@ -1584,7 +1610,7 @@ retry:CompressParam *param = &comp_param[idx];qemu_mutex_lock (¶m->mutex); param->done = false; - bytes_xmit =qemu_put_qemu_file (ms->to_dst_file, param->file); + bytes_xmit =send_queued_data (param);compress_reset_result (param);set_compress_params (param, block, offset);
--
2.40.0
Re: [PATCH v2 05/13] ram.c: Do not call save_page_header() from compress threads
Quoted 9 lines · Lukas Straub
save_page_header()accesses several global variables, so calling it from multiple threads is pretty ugly.Instead, call
save_page_header()before writing out the compressed data from the compress buffer to the migration stream.This also makes the core compress code more independend from
ram.c.Signed-off-by Lukas Straub <[email protected]>
PATCH v2 6/13 ram.c: Call update_compress_thread_counts from compress_send_queued_data
In reply to Lukas StraubThis makes the core compress code more independend from ram.c.
--- migration/ram.c | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-)
migration/ram.c +6 -12
@@ -1551,12 +1551,14 @@ static int send_queued_data(CompressParam *param)abort (); } +update_compress_thread_counts (param, len); +return len; }static void flush_compressed_data (RAMState *rs) { -int idx, len, thread_count; +int idx, thread_count;if (!save_page_use_compression (rs)) {return ;
@@ -1575,15 +1577,8 @@ static void flush_compressed_data(RAMState *rs)qemu_mutex_lock (&comp_param[idx].mutex);if (!comp_param[idx].quit) {CompressParam *param = &comp_param[idx]; - len =send_queued_data (param); +send_queued_data (param);compress_reset_result (param); - -/* -* it's safe to fetch zero_page without holding comp_done_lock -* as there is no further request submitted to the thread, -* i.e, the thread should be waiting for a request at this point. -*/ -update_compress_thread_counts (param, len); }qemu_mutex_unlock (&comp_param[idx].mutex); }
@@ -1599,7 +1594,7 @@ static inline void set_compress_params(CompressParam *param, RAMBlock *block,static int compress_page_with_multi_thread (RAMBlock *block,ram_addr_t offset) { -int idx, thread_count, bytes_xmit =-1 , pages =-1 ; +int idx, thread_count, pages =-1 ;bool wait =migrate_compress_wait_thread (); thread_count =migrate_compress_threads ();
@@ -1610,11 +1605,10 @@ retry:CompressParam *param = &comp_param[idx];qemu_mutex_lock (¶m->mutex); param->done = false; - bytes_xmit =send_queued_data (param); +send_queued_data (param);compress_reset_result (param);set_compress_params (param, block, offset); -update_compress_thread_counts (param, bytes_xmit);qemu_cond_signal (¶m->cond);qemu_mutex_unlock (¶m->mutex); pages =1 ;
--
2.40.0
Re: [PATCH v2 06/13] ram.c: Call update_compress_thread_counts from compress_send_queued_data
Quoted 3 lines · Lukas Straub
This makes the core compress code more independend from
ram.c.Signed-off-by Lukas Straub <[email protected]>
I haven't looked all the series yet
migration/ram.c static void flush_compressed_data(RAMState *rs) · line 1580
Quoted 6 lines
migration/ram.c +1
-1@@ -1575,15 +1577,8 @@ static void flush_compressed_data(RAMState *rs)qemu_mutex_lock (&comp_param[idx].mutex);if (!comp_param[idx].quit) {CompressParam *param = &comp_param[idx]; - len =send_queued_data (param); +send_queued_data (param);
but it appears that send_queued_data don't need to return anything now.
PATCH v2 7/13 ram.c: Remove last ram.c dependency from the core compress code
In reply to Lukas StraubMake compression interfaces take send_queued_data() as an argument. Remove save_page_use_compression() from flush_compressed_data().
This removes the last ram.c dependency from the core compress code.
--- migration/ram.c | 27 +++++++++++++++++---------- 1 file changed, 17 insertions(+), 10 deletions(-)
migration/ram.c +17 -10
@@ -1556,13 +1556,10 @@ static int send_queued_data(CompressParam *param)return len; } -static void flush_compressed_data (RAMState *rs) +static void flush_compressed_data (int (send_queued_data (CompressParam *))) {int idx, thread_count; -if (!save_page_use_compression (rs)) { -return ; - } thread_count =migrate_compress_threads ();qemu_mutex_lock (&comp_done_lock);
@@ -1584,6 +1581,15 @@ static void flush_compressed_data(RAMState *rs) } } +static void ram_flush_compressed_data (RAMState *rs) +{ +if (!save_page_use_compression (rs)) { +return ; + } + +flush_compressed_data (send_queued_data); +} +static inline void set_compress_params (CompressParam *param,RAMBlock *block,ram_addr_t offset) {
@@ -1592,7 +1598,8 @@ static inline void set_compress_params(CompressParam *param, RAMBlock *block, param->trigger = true; } -static int compress_page_with_multi_thread (RAMBlock *block,ram_addr_t offset) +static int compress_page_with_multi_thread (RAMBlock *block,ram_addr_t offset, +int (send_queued_data (CompressParam *))) {int idx, thread_count, pages =-1 ;bool wait =migrate_compress_wait_thread ();
@@ -1673,7 +1680,7 @@ static int find_dirty_block(RAMState *rs, PageSearchStatus *pss)* Also If xbzrle is on, stop using the data compression at this * point. In theory, xbzrle can do better than compression. */ -flush_compressed_data (rs); +ram_flush_compressed_data (rs);/* Hit the end of the list */ pss->block =QLIST_FIRST_RCU (&ram_list.blocks);
@@ -2363,11 +2370,11 @@ static bool save_compress_page(RAMState *rs, PageSearchStatus *pss,* much CPU resource. */ if (block != pss->last_sent_block) { -flush_compressed_data (rs); +ram_flush_compressed_data (rs);return false; } -if (compress_page_with_multi_thread (block, offset) >0 ) { +if (compress_page_with_multi_thread (block, offset, send_queued_data) >0 ) {return true; }
@@ -3419,7 +3426,7 @@ static int ram_save_iterate(QEMUFile *f, void *opaque)* page is sent in one chunk. */ if (migrate_postcopy_ram ()) { -flush_compressed_data (rs); +ram_flush_compressed_data (rs); }/*
@@ -3512,7 +3519,7 @@ static int ram_save_complete(QEMUFile *f, void *opaque) }qemu_mutex_unlock (&rs->bitmap_mutex); -flush_compressed_data (rs); +ram_flush_compressed_data (rs);ram_control_after_iterate (f,RAM_CONTROL_FINISH ); }
--
2.40.0
Re: [PATCH v2 07/13] ram.c: Remove last ram.c dependency from the core compress code
Quoted 6 lines · Lukas Straub
Make compression interfaces take
send_queued_data()as an argument. Removesave_page_use_compression()fromflush_compressed_data().This removes the last
ram.cdependency from the core compress code.Signed-off-by Lukas Straub <[email protected]>
PATCH v2 8/13 ram.c: Introduce whitespace (squash with next patch)
In reply to Lukas StraubIntroduce whitespace to make it easier to reroll the series.
--- migration/ram.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
migration/ram.c +12 -0
@@ -602,6 +602,12 @@ static void *do_data_compress(void *opaque)return NULL ; } + + +/* split */ + + +static void compress_threads_save_cleanup (void ) {int i, thread_count;
@@ -641,6 +647,12 @@ static void compress_threads_save_cleanup(void) comp_param =NULL ; } + + +/* split */ + + +static int compress_threads_save_setup (void ) {int i, thread_count;
--
2.40.0
Re: [PATCH v2 08/13] ram.c: Introduce whitespace (squash with next patch)
Quoted 3 lines · Lukas Straub
Introduce whitespace to make it easier to reroll the series.
Signed-off-by Lukas Straub <[email protected]>
obviously skipped.
PATCH v2 9/13 ram.c: Move core compression code into its own file
In reply to Lukas StraubNo functional changes intended.
--- migration/meson.build | 5 +- migration/ram-compress.c | 273 +++++++++++++++++++++++++++++++++++++++ migration/ram-compress.h | 65 ++++++++++ migration/ram.c | 256 +----------------------------------- 4 files changed, 343 insertions(+), 256 deletions(-) create mode 100644 migration/ram-compress.c create mode 100644 migration/ram-compress.h
migration/meson.build +4 -1
@@ -36,4 +36,7 @@ endif softmmu_ss.add(when: zstd, if_true: files('multifd-zstd.c')) specific_ss.add(when: 'CONFIG_SOFTMMU', - if_true: files('dirtyrate.c', 'ram.c', 'target.c')) + if_true: files('dirtyrate.c', + 'ram.c', + 'ram-compress.c', + 'target.c'))
migration/ram-compress.c new file +273 -0
273 lines not on this page · raw message
migration/ram-compress.h new file +65 -0
65 lines not on this page · raw message
migration/ram.c +1 -255
326 lines not on this page · raw message
--
2.40.0
PATCH v2 10/13 ram.c: Remove whitespace (squash with previous patch)
In reply to Lukas Straub--- migration/ram.c | 18 ------------------ 1 file changed, 18 deletions(-)
migration/ram.c +0 -18
@@ -529,24 +529,6 @@ static bool pss_overlap(PageSearchStatus *pss1, PageSearchStatus *pss2) (pss1->host_page_start == pss2->host_page_start); } - - - - -/* split */ - - - - - - - -/* split */ - - - - -/** * save_page_header: write page header to wire *
--
2.40.0
Re: [PATCH v2 10/13] ram.c: Remove whitespace (squash with previous patch)
Quoted 1 line · Lukas Straub
Signed-off-by Lukas Straub <[email protected]>
obviously skipped
PATCH v2 11/13 ram.c: Move core decompression code into its own file
In reply to Lukas StraubNo functional changes intended.
--- migration/ram-compress.c | 203 ++++++++++++++++++++++++++++++++++++++ migration/ram-compress.h | 5 + migration/ram.c | 204 --------------------------------------- 3 files changed, 208 insertions(+), 204 deletions(-)
migration/ram-compress.c +203 -0
@@ -47,6 +47,24 @@ static QemuThread *compress_threads;static QemuMutex comp_done_lock;static QemuCond comp_done_cond; +struct DecompressParam { +bool done; +bool quit; +QemuMutex mutex; +QemuCond cond; +void *des; +uint8_t *compbuf; +int len; +z_stream stream; +}; +typedef struct DecompressParam DecompressParam ; + +static QEMUFile *decomp_file; +static DecompressParam *decomp_param; +static QemuThread *decompress_threads; +static QemuMutex decomp_done_lock; +static QemuCond decomp_done_cond; +static CompressResult do_compress_ram_page (QEMUFile *f,z_stream *stream,RAMBlock *block,ram_addr_t offset,uint8_t *source_buf);
@@ -271,3 +289,188 @@ retry:return pages; } + +/* return the size after decompression, or negative value on error */ +static int +qemu_uncompress_data (z_stream *stream,uint8_t *dest,size_t dest_len, +const uint8_t *source,size_t source_len) +{ +int err; + + err =inflateReset (stream); +if (err !=Z_OK ) { +return -1 ; + } + + stream->avail_in = source_len; + stream->next_in = (uint8_t *)source; + stream->avail_out = dest_len; + stream->next_out = dest; + + err =inflate (stream,Z_NO_FLUSH ); +if (err !=Z_STREAM_END ) { +return -1 ; + } + +return stream->total_out; +} + +static void *do_data_decompress (void *opaque) +{ +DecompressParam *param = opaque; +unsigned long pagesize; +uint8_t *des; +int len, ret; + +qemu_mutex_lock (¶m->mutex); +while (!param->quit) { +if (param->des) { + des = param->des; + len = param->len; + param->des =0 ; +qemu_mutex_unlock (¶m->mutex); + + pagesize =TARGET_PAGE_SIZE ; + + ret =qemu_uncompress_data (¶m->stream, des, pagesize, + param->compbuf, len); +if (ret <0 &&migrate_get_current ()->decompress_error_check) { +error_report ("decompress data failed" ); +qemu_file_set_error (decomp_file, ret); + } + +qemu_mutex_lock (&decomp_done_lock); + param->done = true; +qemu_cond_signal (&decomp_done_cond); +qemu_mutex_unlock (&decomp_done_lock); + +qemu_mutex_lock (¶m->mutex); + }else { +qemu_cond_wait (¶m->cond, ¶m->mutex); + } + } +qemu_mutex_unlock (¶m->mutex); + +return NULL ; +} + +int wait_for_decompress_done (void ) +{ +int idx, thread_count; + +if (!migrate_use_compression ()) { +return 0 ; + } + + thread_count =migrate_decompress_threads (); +qemu_mutex_lock (&decomp_done_lock); +for (idx =0 ; idx < thread_count; idx++) { +while (!decomp_param[idx].done) { +qemu_cond_wait (&decomp_done_cond, &decomp_done_lock); + } + } +qemu_mutex_unlock (&decomp_done_lock); +return qemu_file_get_error (decomp_file); +} + +void compress_threads_load_cleanup (void ) +{ +int i, thread_count; + +if (!migrate_use_compression ()) { +return ; + } + thread_count =migrate_decompress_threads (); +for (i =0 ; i < thread_count; i++) { +/* +* we use it as a indicator which shows if the thread is +* properly init'd or not +*/ +if (!decomp_param[i].compbuf) { +break ; + } + +qemu_mutex_lock (&decomp_param[i].mutex); + decomp_param[i].quit = true; +qemu_cond_signal (&decomp_param[i].cond); +qemu_mutex_unlock (&decomp_param[i].mutex); + } +for (i =0 ; i < thread_count; i++) { +if (!decomp_param[i].compbuf) { +break ; + } + +qemu_thread_join (decompress_threads + i); +qemu_mutex_destroy (&decomp_param[i].mutex); +qemu_cond_destroy (&decomp_param[i].cond); +inflateEnd (&decomp_param[i].stream); +g_free (decomp_param[i].compbuf); + decomp_param[i].compbuf =NULL ; + } +g_free (decompress_threads); +g_free (decomp_param); + decompress_threads =NULL ; + decomp_param =NULL ; + decomp_file =NULL ; +} + +int compress_threads_load_setup (QEMUFile *f) +{ +int i, thread_count; + +if (!migrate_use_compression ()) { +return 0 ; + } + + thread_count =migrate_decompress_threads (); + decompress_threads =g_new0 (QemuThread, thread_count); + decomp_param =g_new0 (DecompressParam, thread_count); +qemu_mutex_init (&decomp_done_lock); +qemu_cond_init (&decomp_done_cond); + decomp_file = f; +for (i =0 ; i < thread_count; i++) { +if (inflateInit (&decomp_param[i].stream) !=Z_OK ) { + goto exit; + } + + decomp_param[i].compbuf =g_malloc0 (compressBound (TARGET_PAGE_SIZE )); +qemu_mutex_init (&decomp_param[i].mutex); +qemu_cond_init (&decomp_param[i].cond); + decomp_param[i].done = true; + decomp_param[i].quit = false; +qemu_thread_create (decompress_threads + i,"decompress" , + do_data_decompress, decomp_param + i, +QEMU_THREAD_JOINABLE ); + } +return 0 ; +exit: +compress_threads_load_cleanup (); +return -1 ; +} + +void decompress_data_with_multi_threads (QEMUFile *f,void *host,int len) +{ +int idx, thread_count; + + thread_count =migrate_decompress_threads (); +QEMU_LOCK_GUARD (&decomp_done_lock); +while (true) { +for (idx =0 ; idx < thread_count; idx++) { +if (decomp_param[idx].done) { + decomp_param[idx].done = false; +qemu_mutex_lock (&decomp_param[idx].mutex); +qemu_get_buffer (f, decomp_param[idx].compbuf, len); + decomp_param[idx].des = host; + decomp_param[idx].len = len; +qemu_cond_signal (&decomp_param[idx].cond); +qemu_mutex_unlock (&decomp_param[idx].mutex); +break ; + } + } +if (idx < thread_count) { +break ; + }else { +qemu_cond_wait (&decomp_done_cond, &decomp_done_lock); + } + } +}
migration/ram-compress.h +5 -0
@@ -62,4 +62,9 @@ void flush_compressed_data(int (send_queued_data(CompressParam *)));int compress_page_with_multi_thread (RAMBlock *block,ram_addr_t offset,int (send_queued_data (CompressParam *))); +int wait_for_decompress_done (void ); +void compress_threads_load_cleanup (void ); +int compress_threads_load_setup (QEMUFile *f); +void decompress_data_with_multi_threads (QEMUFile *f,void *host,int len); +#endif
migration/ram.c +0 -204
216 lines not on this page · raw message
--
2.40.0
Re: [PATCH v2 11/13] ram.c: Move core decompression code into its own file
Quoted 4 lines · Lukas Straub
No functional changes intended.
Signed-off-by Lukas Straub <[email protected]>Reviewed-by Philippe Mathieu-Daudé <[email protected]>
PATCH v2 12/13 ram compress: Assert that the file buffer matches the result
In reply to Lukas StraubBefore this series, "nothing to send" was handled by the file buffer being empty. Now it is tracked via param->result.
Assert that the file buffer state matches the result.
--- migration/qemu-file.c | 11 +++++++++++ migration/qemu-file.h | 1 + migration/ram-compress.c | 5 +++++ migration/ram.c | 2 ++ 4 files changed, 19 insertions(+)
migration/qemu-file.c +11 -0
@@ -887,6 +887,17 @@ int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src)return len; } +/* +* Check if the writable buffer is empty +*/ + +bool qemu_file_buffer_empty (QEMUFile *file) +{ +assert (qemu_file_is_writable (file)); + +return !file->iovcnt; +} +/* * Get a string whose length is determined by a single preceding byte * A preallocated 256 byte buffer must be passed in.
migration/qemu-file.h +1 -0
@@ -113,6 +113,7 @@ size_t qemu_get_buffer_in_place(QEMUFile *f, uint8_t **buf, size_t size);ssize_t qemu_put_compression_data (QEMUFile *f,z_stream *stream,const uint8_t *p,size_t size);int qemu_put_qemu_file (QEMUFile *f_des,QEMUFile *f_src); +bool qemu_file_buffer_empty (QEMUFile *file);/* * Note that you can only peek continuous bytes from where the current pointer
migration/ram-compress.c +5 -0
@@ -193,6 +193,8 @@ static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,uint8_t *p = block->host + offset;int ret; +assert (qemu_file_buffer_empty (f)); +if (buffer_is_zero (p,TARGET_PAGE_SIZE )) {return RES_ZEROPAGE ; }
@@ -207,6 +209,7 @@ static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,if (ret <0 ) {qemu_file_set_error (migrate_get_current ()->to_dst_file, ret);error_report ("compressed data failed!" ); +qemu_fflush (f);return RES_NONE ; }return RES_COMPRESS ;
@@ -238,6 +241,7 @@ void flush_compressed_data(int (send_queued_data(CompressParam *)))if (!comp_param[idx].quit) {CompressParam *param = &comp_param[idx];send_queued_data (param); +assert (qemu_file_buffer_empty (param->file));compress_reset_result (param); }qemu_mutex_unlock (&comp_param[idx].mutex);
@@ -267,6 +271,7 @@ retry:qemu_mutex_lock (¶m->mutex); param->done = false;send_queued_data (param); +assert (qemu_file_buffer_empty (param->file));compress_reset_result (param);set_compress_params (param, block, offset);
migration/ram.c +2 -0
@@ -1332,11 +1332,13 @@ static int send_queued_data(CompressParam *param)assert (block == pss->last_sent_block);if (param->result ==RES_ZEROPAGE ) { +assert (qemu_file_buffer_empty (param->file)); len +=save_page_header (pss, file, block, offset |RAM_SAVE_FLAG_ZERO );qemu_put_byte (file,0 ); len +=1 ;ram_release_page (block->idstr, offset); }else if (param->result ==RES_COMPRESS ) { +assert (!qemu_file_buffer_empty (param->file)); len +=save_page_header (pss, file, block, offset |RAM_SAVE_FLAG_COMPRESS_PAGE ); len +=qemu_put_qemu_file (file, param->file);
--
2.40.0
Re: [PATCH v2 12/13] ram compress: Assert that the file buffer matches the result
Quoted 6 lines · Lukas Straub
Before this series, "nothing to send" was handled by the file buffer being empty. Now it is tracked via
param->result.Assert that the file buffer state matches the result.
Signed-off-by Lukas Straub <[email protected]>
Even when:
migration/qemu-file.c int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src) · line 896
Quoted 7 lines
migration/qemu-file.c +7
-0+/* +* Check if the writable buffer is empty +*/ + +bool qemu_file_buffer_empty (QEMUFile *file) +{ +assert (qemu_file_is_writable (file));
A function that is basically an assert
Quoted 1 line
+ assert(qemu_file_buffer_empty(f));
Is always called as an assert O:-)
PATCH v2 13/13 ram-compress.c: Make target independent
In reply to Lukas StraubMake ram-compress.c target independent.
--- migration/meson.build | 2 +- migration/ram-compress.c | 17 ++++++++++------- 2 files changed, 11 insertions(+), 8 deletions(-)
migration/meson.build +1 -1
@@ -22,6 +22,7 @@ softmmu_ss.add(files( 'migration.c', 'multifd.c', 'multifd-zlib.c', + 'ram-compress.c', 'postcopy-ram.c', 'savevm.c', 'socket.c',
@@ -38,5 +39,4 @@ softmmu_ss.add(when: zstd, if_true: files('multifd-zstd.c')) specific_ss.add(when: 'CONFIG_SOFTMMU', if_true: files('dirtyrate.c', 'ram.c', - 'ram-compress.c', 'target.c'))
migration/ram-compress.c +10 -7
@@ -34,7 +34,8 @@#include "qemu/error-report.h" #include "migration.h" #include "io/channel-null.h" -#include "exec/ram_addr.h" +#include "exec/target_page.h" +#include "exec/ramblock.h" CompressionStats compression_counters;
@@ -155,7 +156,7 @@ int compress_threads_save_setup(void)qemu_cond_init (&comp_done_cond);qemu_mutex_init (&comp_done_lock);for (i =0 ; i < thread_count; i++) { - comp_param[i].originbuf =g_try_malloc (TARGET_PAGE_SIZE ); + comp_param[i].originbuf =g_try_malloc (qemu_target_page_size ());if (!comp_param[i].originbuf) { goto exit; }
@@ -191,11 +192,12 @@ static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream, uint8_t *source_buf) {uint8_t *p = block->host + offset; +size_t page_size =qemu_target_page_size ();int ret;assert (qemu_file_buffer_empty (f)); -if (buffer_is_zero (p,TARGET_PAGE_SIZE )) { +if (buffer_is_zero (p, page_size)) {return RES_ZEROPAGE ; }
@@ -204,8 +206,8 @@ static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,* so that we can catch up the error during compression and * decompression */ -memcpy (source_buf, p,TARGET_PAGE_SIZE ); - ret =qemu_put_compression_data (f, stream, source_buf,TARGET_PAGE_SIZE ); +memcpy (source_buf, p, page_size); + ret =qemu_put_compression_data (f, stream, source_buf, page_size);if (ret <0 ) {qemu_file_set_error (migrate_get_current ()->to_dst_file, ret);error_report ("compressed data failed!" );
@@ -335,7 +337,7 @@ static void *do_data_decompress(void *opaque) param->des =0 ;qemu_mutex_unlock (¶m->mutex); - pagesize =TARGET_PAGE_SIZE ; + pagesize =qemu_target_page_size (); ret =qemu_uncompress_data (¶m->stream, des, pagesize, param->compbuf, len);
@@ -438,7 +440,8 @@ int compress_threads_load_setup(QEMUFile *f) goto exit; } - decomp_param[i].compbuf =g_malloc0 (compressBound (TARGET_PAGE_SIZE )); +size_t compbuf_size =compressBound (qemu_target_page_size ()); + decomp_param[i].compbuf =g_malloc0 (compbuf_size);qemu_mutex_init (&decomp_param[i].mutex);qemu_cond_init (&decomp_param[i].cond); decomp_param[i].done = true;
--
2.40.0
Re: [PATCH v2 13/13] ram-compress.c: Make target independent
Quoted 3 lines · Lukas Straub
Make
ram-compress.ctarget independent.Signed-off-by Lukas Straub <[email protected]>
[PATCH v2 14/13] migration: Initialize and cleanup decompression in migration.c
In reply to Lukas StraubThis fixes compress with colo.
---
Oops, this one slipped trough
migration/migration.c | 9 +++++++++ migration/ram.c | 5 ----- 2 files changed, 9 insertions(+), 5 deletions(-)
migration/migration.c +9 -0
@@ -26,6 +26,7 @@#include "sysemu/cpu-throttle.h" #include "rdma.h" #include "ram.h" +#include "ram-compress.h" #include "migration/global_state.h" #include "migration/misc.h" #include "migration.h"
@@ -316,6 +317,7 @@ void migration_incoming_state_destroy(void)struct MigrationIncomingState *mis =migration_incoming_get_current ();multifd_load_cleanup (); +compress_threads_load_cleanup ();if (mis->to_src_file) {/* Tell source that we are done */
@@ -598,6 +600,12 @@ process_incoming_migration_co(void *opaque)Error *local_err =NULL ;assert (mis->from_src_file); + +if (compress_threads_load_setup (mis->from_src_file)) { +error_report ("Failed to setup decompress threads" ); + goto fail; + } + mis->migration_incoming_co =qemu_coroutine_self (); mis->largest_page_size =qemu_ram_pagesize_largest ();postcopy_state_set (POSTCOPY_INCOMING_NONE );
@@ -663,6 +671,7 @@ fail:qemu_fclose (mis->from_src_file);multifd_load_cleanup (); +compress_threads_load_cleanup ();exit (EXIT_FAILURE ); }
migration/ram.c +0 -5
@@ -3560,10 +3560,6 @@ void colo_release_ram_cache(void)*/ static int ram_load_setup (QEMUFile *f,void *opaque) { -if (compress_threads_load_setup (f)) { -return -1 ; - } -xbzrle_load_setup ();ramblock_recv_map_init ();
@@ -3579,7 +3575,6 @@ static int ram_load_cleanup(void *opaque) }xbzrle_load_cleanup (); -compress_threads_load_cleanup ();RAMBLOCK_FOREACH_NOT_IGNORED (rb) {g_free (rb->receivedmap);
Signature · 1 line
2.40.0
Juan Quintela
Reviewed-byRe: [PATCH v2 14/13] migration: Initialize and cleanup decompression in migration.c
Quoted 3 lines · Lukas Straub
This fixes compress with colo.
Signed-off-by Lukas Straub <[email protected]>
Quoted 3 lines
---
Oops, this one slipped trough
As the saying goes, it happes in the best families.
Yeap, it is a literal translation of a Spanish saying O:-)