OpenE2K/qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

migration: Use "i" as an for index in ram-compress.c

Browse Source 
It is used everywhere else in C.  Once there, make sure that we don't
use the index outside of the for declaring the variable there.

Signed-off-by: Juan Quintela <quintela@redhat.com>
Reviewed-by: Lukas Straub <lukasstraub2@web.de>
Message-ID: <20230613145757.10131-15-quintela@redhat.com>
This commit is contained in:
Juan Quintela 2023-06-13 16:57:53 +02:00
parent 4703d1958c
commit bef4e2ed8e
1 changed files with 25 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
migration/ram-compress.c
View File

@ -230,27 +230,25 @@ static inline void compress_reset_result(CompressParam *param)
void flush_compressed_data(int (send_queued_data(CompressParam *))) void flush_compressed_data(int (send_queued_data(CompressParam *)))
{ {
int idx, thread_count; int thread_count = migrate_compress_threads();
thread_count = migrate_compress_threads();
qemu_mutex_lock(&comp_done_lock); qemu_mutex_lock(&comp_done_lock);
for (idx = 0; idx < thread_count; idx++) { for (int i = 0; i < thread_count; i++) {
while (!comp_param[idx].done) { while (!comp_param[i].done) {
qemu_cond_wait(&comp_done_cond, &comp_done_lock); qemu_cond_wait(&comp_done_cond, &comp_done_lock);
} }
} }
qemu_mutex_unlock(&comp_done_lock); qemu_mutex_unlock(&comp_done_lock);
for (idx = 0; idx < thread_count; idx++) { for (int i = 0; i < thread_count; i++) {
qemu_mutex_lock(&comp_param[idx].mutex); qemu_mutex_lock(&comp_param[i].mutex);
if (!comp_param[idx].quit) { if (!comp_param[i].quit) {
CompressParam *param = &comp_param[idx]; CompressParam *param = &comp_param[i];
send_queued_data(param); send_queued_data(param);
assert(qemu_file_buffer_empty(param->file)); assert(qemu_file_buffer_empty(param->file));
compress_reset_result(param); compress_reset_result(param);
} }
qemu_mutex_unlock(&comp_param[idx].mutex); qemu_mutex_unlock(&comp_param[i].mutex);
} }
} }
@ -265,15 +263,15 @@ static inline void set_compress_params(CompressParam *param, RAMBlock *block,
int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset, int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset,
int (send_queued_data(CompressParam *))) int (send_queued_data(CompressParam *)))
{ {
int idx, thread_count, pages = -1; int thread_count, pages = -1;
bool wait = migrate_compress_wait_thread(); bool wait = migrate_compress_wait_thread();
thread_count = migrate_compress_threads(); thread_count = migrate_compress_threads();
qemu_mutex_lock(&comp_done_lock); qemu_mutex_lock(&comp_done_lock);
retry: retry:
for (idx = 0; idx < thread_count; idx++) { for (int i = 0; i < thread_count; i++) {
if (comp_param[idx].done) { if (comp_param[i].done) {
CompressParam *param = &comp_param[idx]; CompressParam *param = &comp_param[i];
qemu_mutex_lock(&param->mutex); qemu_mutex_lock(&param->mutex);
param->done = false; param->done = false;
send_queued_data(param); send_queued_data(param);
@ -367,16 +365,14 @@ static void *do_data_decompress(void *opaque)
int wait_for_decompress_done(void) int wait_for_decompress_done(void)
{ {
int idx, thread_count;
if (!migrate_compress()) { if (!migrate_compress()) {
return 0; return 0;
} }
thread_count = migrate_decompress_threads(); int thread_count = migrate_decompress_threads();
qemu_mutex_lock(&decomp_done_lock); qemu_mutex_lock(&decomp_done_lock);
for (idx = 0; idx < thread_count; idx++) { for (int i = 0; i < thread_count; i++) {
while (!decomp_param[idx].done) { while (!decomp_param[i].done) {
qemu_cond_wait(&decomp_done_cond, &decomp_done_lock); qemu_cond_wait(&decomp_done_cond, &decomp_done_lock);
} }
} }
@ -467,20 +463,18 @@ exit:
void decompress_data_with_multi_threads(QEMUFile *f, void *host, int len) void decompress_data_with_multi_threads(QEMUFile *f, void *host, int len)
{ {
int idx, thread_count; int thread_count = migrate_decompress_threads();
thread_count = migrate_decompress_threads();
QEMU_LOCK_GUARD(&decomp_done_lock); QEMU_LOCK_GUARD(&decomp_done_lock);
while (true) { while (true) {
for (idx = 0; idx < thread_count; idx++) { for (int i = 0; i < thread_count; i++) {
if (decomp_param[idx].done) { if (decomp_param[i].done) {
decomp_param[idx].done = false; decomp_param[i].done = false;
qemu_mutex_lock(&decomp_param[idx].mutex); qemu_mutex_lock(&decomp_param[i].mutex);
qemu_get_buffer(f, decomp_param[idx].compbuf, len); qemu_get_buffer(f, decomp_param[i].compbuf, len);
decomp_param[idx].des = host; decomp_param[i].des = host;
decomp_param[idx].len = len; decomp_param[i].len = len;
qemu_cond_signal(&decomp_param[idx].cond); qemu_cond_signal(&decomp_param[i].cond);
qemu_mutex_unlock(&decomp_param[idx].mutex); qemu_mutex_unlock(&decomp_param[i].mutex);
return; return;
} }
} }