haraldwolff/qemu-patch-raspberry4
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

migration: refine the decompression code

Browse source 
The current code for multi-thread decompression is not clear,
especially in the aspect of using lock. Refine the code
to make it clear.

Signed-off-by: Liang Li <liang.z.li@intel.com>
Message-Id: <1462433579-13691-9-git-send-email-liang.z.li@intel.com>
Signed-off-by: Amit Shah <amit.shah@redhat.com>
This commit is contained in:
Liang Li 2016-05-05 15:32:58 +08:00 committed by Amit Shah
parent a7a9a88f9d
commit 33d151f418
1 changed files with 25 additions and 25 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

50
migration/ram.c
View file

@ -264,7 +264,6 @@ struct CompressParam {
typedef struct CompressParam CompressParam; typedef struct CompressParam CompressParam;
struct DecompressParam { struct DecompressParam {
bool start;
bool done; bool done;
bool quit; bool quit;
QemuMutex mutex; QemuMutex mutex;
@ -830,15 +829,6 @@ static int do_compress_ram_page(QEMUFile *f, RAMBlock *block,
return bytes_sent; return bytes_sent;
} }
static inline void start_decompression(DecompressParam *param)
{
param->done = false;
qemu_mutex_lock(&param->mutex);
param->start = true;
qemu_cond_signal(&param->cond);
qemu_mutex_unlock(&param->mutex);
}
static uint64_t bytes_transferred; static uint64_t bytes_transferred;
static void flush_compressed_data(QEMUFile *f) static void flush_compressed_data(QEMUFile *f)
@ -2198,30 +2188,37 @@ static void *do_data_decompress(void *opaque)
{ {
DecompressParam *param = opaque; DecompressParam *param = opaque;
unsigned long pagesize; unsigned long pagesize;
uint8_t *des;
int len;
qemu_mutex_lock(&param->mutex);
while (!param->quit) { while (!param->quit) {
qemu_mutex_lock(&param->mutex); if (param->des) {
while (!param->start && !param->quit) { des = param->des;
qemu_cond_wait(&param->cond, &param->mutex); len = param->len;
} param->des = 0;
if (!param->quit) { qemu_mutex_unlock(&param->mutex);
pagesize = TARGET_PAGE_SIZE; pagesize = TARGET_PAGE_SIZE;
/* uncompress() will return failed in some case, especially /* uncompress() will return failed in some case, especially
* when the page is dirted when doing the compression, it's * when the page is dirted when doing the compression, it's
* not a problem because the dirty page will be retransferred * not a problem because the dirty page will be retransferred
* and uncompress() won't break the data in other pages. * and uncompress() won't break the data in other pages.
*/ */
uncompress((Bytef *)param->des, &pagesize, uncompress((Bytef *)des, &pagesize,
(const Bytef *)param->compbuf, param->len); (const Bytef *)param->compbuf, len);
}
param->start = false;
qemu_mutex_unlock(&param->mutex);
qemu_mutex_lock(&decomp_done_lock); qemu_mutex_lock(&decomp_done_lock);
param->done = true; param->done = true;
qemu_cond_signal(&decomp_done_cond); qemu_cond_signal(&decomp_done_cond);
qemu_mutex_unlock(&decomp_done_lock); qemu_mutex_unlock(&decomp_done_lock);
qemu_mutex_lock(&param->mutex);
} else {
qemu_cond_wait(&param->cond, &param->mutex);
}
} }
qemu_mutex_unlock(&param->mutex);
return NULL; return NULL;
} }
@ -2298,10 +2295,13 @@ static void decompress_data_with_multi_threads(QEMUFile *f,
while (true) { while (true) {
for (idx = 0; idx < thread_count; idx++) { for (idx = 0; idx < thread_count; idx++) {
if (decomp_param[idx].done) { 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); qemu_get_buffer(f, decomp_param[idx].compbuf, len);
decomp_param[idx].des = host; decomp_param[idx].des = host;
decomp_param[idx].len = len; decomp_param[idx].len = len;
start_decompression(&decomp_param[idx]); qemu_cond_signal(&decomp_param[idx].cond);
qemu_mutex_unlock(&decomp_param[idx].mutex);
break; break;
} }
} }