ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

buffered_file: Move from using a timer to use a thread 

We still protect everything except the wait with the iothread lock.
But we moved from a timer to a thread.  Steps one by one.

We also need to detect when we have finished with a variable "complete".

Signed-off-by: Juan Quintela <quintela@redhat.com>
This commit is contained in:
Juan Quintela 2012-07-23 01:56:50 +02:00
parent b2a8658ef5
commit c09f4cb2b3
1 changed files with 36 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
buffered_file.c
View File

@ -17,6 +17,7 @@
#include "hw/hw.h" #include "hw/hw.h"
#include "qemu/timer.h" #include "qemu/timer.h"
#include "buffered_file.h" #include "buffered_file.h"
#include "qemu/thread.h"
//#define DEBUG_BUFFERED_FILE //#define DEBUG_BUFFERED_FILE
@ -30,7 +31,8 @@ typedef struct QEMUFileBuffered
uint8_t *buffer; uint8_t *buffer;
size_t buffer_size; size_t buffer_size;
size_t buffer_capacity; size_t buffer_capacity;
QEMUTimer *timer; QemuThread thread;
bool complete;
} QEMUFileBuffered; } QEMUFileBuffered;
#ifdef DEBUG_BUFFERED_FILE #ifdef DEBUG_BUFFERED_FILE
@ -159,11 +161,8 @@ static int buffered_close(void *opaque)
if (ret >= 0) { if (ret >= 0) {
ret = ret2; ret = ret2;
} }
qemu_del_timer(s->timer); ret = migrate_fd_close(s->migration_state);
qemu_free_timer(s->timer); s->complete = true;
g_free(s->buffer);
g_free(s);
return ret; return ret;
} }
@ -221,23 +220,38 @@ static int64_t buffered_get_rate_limit(void *opaque)
return s->xfer_limit; return s->xfer_limit;
} }
static void buffered_rate_tick(void *opaque) /* 10ms xfer_limit is the limit that we should write each 10ms */
#define BUFFER_DELAY 100
static void *buffered_file_thread(void *opaque)
{ {
QEMUFileBuffered *s = opaque; QEMUFileBuffered *s = opaque;
int64_t expire_time = qemu_get_clock_ms(rt_clock) + BUFFER_DELAY;
if (qemu_file_get_error(s->file)) { while (true) {
buffered_close(s); int64_t current_time = qemu_get_clock_ms(rt_clock);
return;
if (s->complete) {
break;
}
if (s->freeze_output) {
continue;
}
if (current_time >= expire_time) {
s->bytes_xfer = 0;
expire_time = current_time + BUFFER_DELAY;
}
if (s->bytes_xfer >= s->xfer_limit) {
/* usleep expects microseconds */
g_usleep((expire_time - current_time)*1000);
}
qemu_mutex_lock_iothread();
buffered_put_buffer(s, NULL, 0, 0);
qemu_mutex_unlock_iothread();
} }
g_free(s->buffer);
qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 100); g_free(s);
return NULL;
if (s->freeze_output)
return;
s->bytes_xfer = 0;
buffered_put_buffer(s, NULL, 0, 0);
} }
static const QEMUFileOps buffered_file_ops = { static const QEMUFileOps buffered_file_ops = {
@ -257,12 +271,12 @@ QEMUFile *qemu_fopen_ops_buffered(MigrationState *migration_state)
s->migration_state = migration_state; s->migration_state = migration_state;
s->xfer_limit = migration_state->bandwidth_limit / 10; s->xfer_limit = migration_state->bandwidth_limit / 10;
s->complete = false;
s->file = qemu_fopen_ops(s, &buffered_file_ops); s->file = qemu_fopen_ops(s, &buffered_file_ops);
s->timer = qemu_new_timer_ms(rt_clock, buffered_rate_tick, s); qemu_thread_create(&s->thread, buffered_file_thread, s,
QEMU_THREAD_DETACHED);
qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 100);
return s->file; return s->file;
} }