latency, since queue/complete is one operation there. This
value can be in milliseconds or microseconds, fio will choose
the most appropriate base and print that. In the example
- above, milliseconds is the best scale.
+ above, milliseconds is the best scale. Note: in --minimal mode
+ latencies are always expressed in microseconds.
clat= Completion latency. Same names as slat, this denotes the
time from submission to completion of the io pieces. For
sync io, clat will usually be equal (or very close) to 0,
Completion latency: min, max, mean, deviation (usec)
Completion latency percentiles: 20 fields (see below)
Total latency: min, max, mean, deviation (usec)
- Bw: min, max, aggregate percentage of total, mean, deviation
+ Bw (KB/s): min, max, aggregate percentage of total, mean, deviation
WRITE status:
Total IO (KB), bandwidth (KB/sec), IOPS, runtime (msec)
Submission latency: min, max, mean, deviation (usec)
Completion latency: min, max, mean, deviation (usec)
Completion latency percentiles: 20 fields (see below)
Total latency: min, max, mean, deviation (usec)
- Bw: min, max, aggregate percentage of total, mean, deviation
+ Bw (KB/s): min, max, aggregate percentage of total, mean, deviation
CPU usage: user, system, context switches, major faults, minor faults
IO depths: <=1, 2, 4, 8, 16, 32, >=64
IO latencies microseconds: <=2, 4, 10, 20, 50, 100, 250, 500, 750, 1000
}
if (!rc) {
- for (i = 0; i < td->o.iodepth; i++) {
- wd->ovls[i].io_free = TRUE;
- wd->ovls[i].io_complete = FALSE;
+ for (i = 0; i < td->o.iodepth; i++) {
+ wd->ovls[i].io_free = TRUE;
+ wd->ovls[i].io_complete = FALSE;
wd->ovls[i].o.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (wd->ovls[i].o.hEvent == NULL) {
rc = 1;
break;
}
- }
+ }
}
if (!rc) {
if (fov->io_complete) {
fov->io_complete = FALSE;
fov->io_free = TRUE;
+ ResetEvent(fov->o.hEvent);
wd->aio_events[dequeued] = io_u;
dequeued++;
}
if (dequeued < min) {
status = WaitForSingleObject(wd->iocomplete_event, mswait);
- if (status != WAIT_OBJECT_0 && dequeued > 0)
+ if (status != WAIT_OBJECT_0 && dequeued >= min)
break;
}
wd = td->io_ops->data;
for (index = 0; index < td->o.iodepth; index++) {
- if (wd->ovls[index].io_free) {
- wd->ovls[index].io_free = FALSE;
- ResetEvent(wd->ovls[index].o.hEvent);
+ if (wd->ovls[index].io_free)
break;
- }
}
assert(index < td->o.iodepth);
- lpOvl = &wd->ovls[index].o;
+ wd->ovls[index].io_free = FALSE;
wd->ovls[index].io_u = io_u;
+ lpOvl = &wd->ovls[index].o;
lpOvl->Internal = STATUS_PENDING;
lpOvl->InternalHigh = 0;
lpOvl->Offset = io_u->offset & 0xFFFFFFFF;
extern int groupid;
extern int terse_output;
extern int temp_stall_ts;
-extern unsigned long page_mask, page_size;
+extern uintptr_t page_mask, page_size;
extern int read_only;
extern int eta_print;
extern unsigned long done_secs;
else if (ipo->offset > __ipo->offset)
p = &(*p)->rb_right;
else {
- assert(ipo->len == __ipo->len);
+ dprint(FD_IO, "iolog: overlap %llu/%lu, %llu/%lu",
+ __ipo->offset, __ipo->len,
+ ipo->offset, ipo->len);
td->io_hist_len--;
rb_erase(parent, &td->io_hist_tree);
remove_trim_entry(td, __ipo);
unsigned long arch_flags = 0;
-unsigned long page_mask;
-unsigned long page_size;
+uintptr_t page_mask;
+uintptr_t page_size;
static const char *fio_os_strings[os_nr] = {
"Invalid",
#define FIO_HAVE_CHARDEV_SIZE
#define FIO_HAVE_FDATASYNC
#define FIO_HAVE_WINDOWSAIO
+#define FIO_HAVE_FALLOCATE
#define FIO_HAVE_GETTID
#define FIO_HAVE_CLOCK_MONOTONIC
#define FIO_USE_GENERIC_RAND
int posix_fallocate(int fd, off_t offset, off_t len)
{
- log_err("%s is not implemented\n", __func__);
- errno = ENOSYS;
- return (-1);
+ const int BUFFER_SIZE = 64*1024*1024;
+ int rc = 0;
+ char *buf;
+ unsigned int write_len;
+ unsigned int bytes_written;
+ off_t bytes_remaining = len;
+
+ if (len == 0 || offset < 0)
+ return EINVAL;
+
+ buf = malloc(BUFFER_SIZE);
+
+ if (buf == NULL)
+ return ENOMEM;
+
+ memset(buf, 0, BUFFER_SIZE);
+
+ if (lseek(fd, offset, SEEK_SET) == -1)
+ return errno;
+
+ while (bytes_remaining > 0) {
+ if (bytes_remaining < BUFFER_SIZE)
+ write_len = (unsigned int)bytes_remaining;
+ else
+ write_len = BUFFER_SIZE;
+
+ bytes_written = _write(fd, buf, write_len);
+ if (bytes_written == -1) {
+ rc = errno;
+ break;
+ }
+
+ bytes_remaining -= bytes_written;
+ }
+
+ free(buf);
+ return rc;
}
int ftruncate(int fildes, off_t length)
int rc;
if (timeout != -1)
- to = &tv;
+ to = &tv;
to->tv_sec = timeout / 1000;
to->tv_usec = (timeout % 1000) * 1000;
if (fds[i].events & POLLOUT)
FD_SET(fds[i].fd, &writefds);
- FD_SET(fds[i].fd, &exceptfds);
+ FD_SET(fds[i].fd, &exceptfds);
}
rc = select(nfds, &readfds, &writefds, &exceptfds, to);
bw = 0;
if (ts->runtime[j]) {
- unsigned long runt;
+ unsigned long runt = ts->runtime[j];
+ unsigned long long kb;
- runt = ts->runtime[j];
- bw = ts->io_bytes[j] / runt;
+ kb = ts->io_bytes[j] / rs->kb_base;
+ bw = kb * 1000 / runt;
}
if (bw < rs->min_bw[j])
rs->min_bw[j] = bw;
}
for (i = 0; i < groupid + 1; i++) {
- unsigned long max_run[2];
-
rs = &runstats[i];
- max_run[0] = rs->max_run[0];
- max_run[1] = rs->max_run[1];
if (rs->max_run[0])
- rs->agg[0] = (rs->io_kb[0] * 1000) / max_run[0];
+ rs->agg[0] = (rs->io_kb[0] * 1000) / rs->max_run[0];
if (rs->max_run[1])
- rs->agg[1] = (rs->io_kb[1] * 1000) / max_run[1];
+ rs->agg[1] = (rs->io_kb[1] * 1000) / rs->max_run[1];
}
/*