free(log);
}
-static void flush_samples(FILE *f, void *samples, uint64_t sample_size)
+void flush_samples(FILE *f, void *samples, uint64_t sample_size)
{
struct io_sample *s;
int log_offset;
uint64_t nr_samples;
};
-struct iolog_compress {
- struct flist_head list;
- void *buf;
- size_t len;
- unsigned int seq;
-};
-
#define GZ_CHUNK 131072
static struct iolog_compress *get_new_chunk(unsigned int seq)
} else
fio_lock_file(log->filename);
- if (td->client_type == FIO_CLIENT_TYPE_GUI)
+ if (td->client_type == FIO_CLIENT_TYPE_GUI || is_backend)
fio_send_iolog(td, log, log->filename);
else
flush_log(log, !td->o.per_job_logs);
return 0;
}
+size_t log_chunk_sizes(struct io_log *log)
+{
+ struct flist_head *entry;
+ size_t ret;
+
+ if (flist_empty(&log->chunk_list))
+ return 0;
+
+ ret = 0;
+ pthread_mutex_lock(&log->chunk_lock);
+ flist_for_each(entry, &log->chunk_list) {
+ struct iolog_compress *c;
+
+ c = flist_entry(entry, struct iolog_compress, list);
+ ret += c->len;
+ }
+ pthread_mutex_unlock(&log->chunk_lock);
+ return ret;
+}
+
#ifdef CONFIG_ZLIB
static void drop_data_unlock(struct iolog_flush_data *data)
static struct workqueue_ops log_compress_wq_ops = {
.fn = gz_work,
.init_worker_fn = gz_init_worker,
- .nice = 1,
+ .nice = 1,
};
-int iolog_compress_init(struct thread_data *td)
+int iolog_compress_init(struct thread_data *td, struct sk_out *sk_out)
{
if (!(td->flags & TD_F_COMPRESS_LOG))
return 0;
- workqueue_init(td, &td->log_compress_wq, &log_compress_wq_ops, 1);
+ workqueue_init(td, &td->log_compress_wq, &log_compress_wq_ops, 1, sk_out);
return 0;
}
}
/*
- * Queue work item to compress the existing log entries. We copy the
- * samples, and reset the log sample count to 0 (so the logging will
- * continue to use the memory associated with the log). If called with
- * wait == 1, will not return until the log compression has completed.
+ * Queue work item to compress the existing log entries. We reset the
+ * current log to a small size, and reference the existing log in the
+ * data that we queue for compression. Once compression has been done,
+ * this old log is freed. If called with wait == 1, will not return until
+ * the log compression has completed.
*/
int iolog_flush(struct io_log *log, int wait)
{
struct iolog_flush_data *data;
- size_t sample_size;
+
+ io_u_quiesce(log->td);
data = malloc(sizeof(*data));
if (!data)
data->log = log;
- sample_size = log->nr_samples * log_entry_sz(log);
- data->samples = malloc(sample_size);
- if (!data->samples) {
- free(data);
- return 1;
- }
-
- memcpy(data->samples, log->log, sample_size);
+ data->samples = log->log;
data->nr_samples = log->nr_samples;
+
log->nr_samples = 0;
+ log->max_samples = 128;
+ log->log = malloc(log->max_samples * log_entry_sz(log));
data->wait = wait;
if (data->wait) {
return 1;
}
-int iolog_compress_init(struct thread_data *td)
+int iolog_compress_init(struct thread_data *td, struct sk_out *sk_out)
{
return 0;
}