buffer_compress_percentage=int If this is set, then fio will attempt to
provide IO buffer content (on WRITEs) that compress to
the specified level. Fio does this by providing a mix of
- random data and zeroes. Note that this is per block size
- unit, for file/disk wide compression level that matches
- this setting, you'll also want to set refill_buffers.
+ random data and a fixed pattern. The fixed pattern is either
+ zeroes, or the pattern specified by buffer_pattern. If the
+ pattern option is used, it might skew the compression ratio
+ slightly. Note that this is per block size unit, for file/disk
+ wide compression level that matches this setting, you'll also
+ want to set refill_buffers.
buffer_compress_chunk=int See buffer_compress_percentage. This
setting allows fio to manage how big the ranges of random
.BI buffer_compress_percentage \fR=\fPint
If this is set, then fio will attempt to provide IO buffer content (on WRITEs)
that compress to the specified level. Fio does this by providing a mix of
-random data and zeroes. Note that this is per block size unit, for file/disk
-wide compression level that matches this setting, you'll also want to set
-\fBrefill_buffers\fR.
+random data and a fixed pattern. The fixed pattern is either zeroes, or the
+pattern specified by \fBbuffer_pattern\fR. If the pattern option is used, it
+might skew the compression ratio slightly. Note that this is per block size
+unit, for file/disk wide compression level that matches this setting. Note
+that this is per block size unit, for file/disk wide compression level that
+matches this setting, you'll also want to set refill_buffers.
.TP
.BI buffer_compress_chunk \fR=\fPint
See \fBbuffer_compress_percentage\fR. This setting allows fio to manage how
void fill_io_buffer(struct thread_data *td, void *buf, unsigned int min_write,
unsigned int max_bs)
{
- if (td->o.buffer_pattern_bytes)
- fill_buffer_pattern(td, buf, max_bs);
- else if (!td->o.zero_buffers) {
+ struct thread_options *o = &td->o;
+
+ if (o->compress_percentage) {
unsigned int perc = td->o.compress_percentage;
struct frand_state *rs;
unsigned int left = max_bs;
seg = min_write;
fill_random_buf_percentage(rs, buf, perc, seg,
- min_write);
+ min_write, o->buffer_pattern,
+ o->buffer_pattern_bytes);
} else
fill_random_buf(rs, buf, min_write);
left -= min_write;
save_buf_state(td, rs);
} while (left);
- } else
+ } else if (o->buffer_pattern_bytes)
+ fill_buffer_pattern(td, buf, max_bs);
+ else
memset(buf, 0, max_bs);
}
*/
#include <string.h>
+#include <assert.h>
#include "rand.h"
#include "../hash.h"
return r;
}
+void fill_pattern(void *p, unsigned int len, char *pattern,
+ unsigned int pattern_bytes)
+{
+ switch (pattern_bytes) {
+ case 0:
+ assert(0);
+ break;
+ case 1:
+ memset(p, pattern[0], len);
+ break;
+ default: {
+ unsigned int i = 0, size = 0;
+ unsigned char *b = p;
+
+ while (i < len) {
+ size = pattern_bytes;
+ if (size > (len - i))
+ size = len - i;
+ memcpy(b+i, pattern, size);
+ i += size;
+ }
+ break;
+ }
+ }
+}
+
unsigned long fill_random_buf_percentage(struct frand_state *fs, void *buf,
unsigned int percentage,
- unsigned int segment, unsigned int len)
+ unsigned int segment, unsigned int len,
+ char *pattern, unsigned int pbytes)
{
unsigned long r = __rand(fs);
unsigned int this_len;
if (percentage == 100) {
- memset(buf, 0, len);
+ if (pbytes)
+ fill_pattern(buf, len, pattern, pbytes);
+ else
+ memset(buf, 0, len);
return 0;
}
if (this_len > len)
this_len = len;
- memset(buf, 0, this_len);
+ if (pbytes)
+ fill_pattern(buf, this_len, pattern, pbytes);
+ else
+ memset(buf, 0, this_len);
len -= this_len;
buf += this_len;
}
extern void init_rand_seed(struct frand_state *, unsigned int seed);
extern void __fill_random_buf(void *buf, unsigned int len, unsigned long seed);
extern unsigned long fill_random_buf(struct frand_state *, void *buf, unsigned int len);
-extern unsigned long fill_random_buf_percentage(struct frand_state *, void *buf, unsigned int percentage, unsigned int segment, unsigned int len);
+extern unsigned long fill_random_buf_percentage(struct frand_state *, void *, unsigned int, unsigned int, unsigned int, char *, unsigned int);
+extern void fill_pattern(void *p, unsigned int len, char *pattern, unsigned int pattern_bytes);
#endif
struct verify_header *hdr, unsigned int header_num,
unsigned int header_len);
-static void fill_pattern(void *p, unsigned int len, char *pattern,
- unsigned int pattern_bytes)
-{
- switch (pattern_bytes) {
- case 0:
- assert(0);
- break;
- case 1:
- dprint(FD_VERIFY, "fill verify pattern b=0 len=%u\n", len);
- memset(p, pattern[0], len);
- break;
- default: {
- unsigned int i = 0, size = 0;
- unsigned char *b = p;
-
- dprint(FD_VERIFY, "fill verify pattern b=%d len=%u\n",
- pattern_bytes, len);
-
- while (i < len) {
- size = pattern_bytes;
- if (size > (len - i))
- size = len - i;
- memcpy(b+i, pattern, size);
- i += size;
- }
- break;
- }
- }
-}
-
void fill_buffer_pattern(struct thread_data *td, void *p, unsigned int len)
{
fill_pattern(p, len, td->o.buffer_pattern, td->o.buffer_pattern_bytes);