X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=io_u.c;h=f2406e8c1ec91cb86f56196b2f83e33dca9087ca;hp=f2fa859c4bcb4556fa58338b3a7cc6d90f6fdbcd;hb=dbad30b097de39d355b3952a3bb6db9ccf9dd77f;hpb=3e3357b1a54ca27c4b1f5e9564eee73f510e164f

diff --git a/io_u.c b/io_u.c
index f2fa859c..f2406e8c 100644
--- a/io_u.c
+++ b/io_u.c
@@ -8,11 +8,6 @@
 #include "fio.h"
 #include "hash.h"
 
-/*
- * Change this define to play with the timeout handling
- */
-#undef FIO_USE_TIMEOUT
-
 struct io_completion_data {
 	int nr;				/* input */
 
@@ -57,8 +52,11 @@ static void mark_random_map(struct thread_data *td, struct io_u *io_u)
 		 * If we have a mixed random workload, we may
 		 * encounter blocks we already did IO to.
 		 */
-		if ((td->o.ddir_nr == 1) && !random_map_free(f, block))
+		if ((td->o.ddir_nr == 1) && !random_map_free(f, block)) {
+			if (!blocks)
+				blocks = 1;
 			break;
+		}
 
 		idx = RAND_MAP_IDX(f, block);
 		bit = RAND_MAP_BIT(f, block);
@@ -74,10 +72,10 @@ static void mark_random_map(struct thread_data *td, struct io_u *io_u)
 		else
 			mask = ((1U << this_blocks) - 1) << bit;
 
-		fio_assert(td, !(f->file_map[idx] & mask));
 		f->file_map[idx] |= mask;
 		nr_blocks -= this_blocks;
 		blocks += this_blocks;
+		block += this_blocks;
 	}
 
 	if ((blocks * min_bs) < io_u->buflen)
@@ -142,7 +140,7 @@ static int get_next_rand_offset(struct thread_data *td, struct fio_file *f,
 		r = os_random_long(&td->random_state);
 		dprint(FD_RANDOM, "off rand %llu\n", r);
 		*b = (last_block(td, f, ddir) - 1)
-			* (r / ((unsigned long long) RAND_MAX + 1.0));
+			* (r / ((unsigned long long) OS_RAND_MAX + 1.0));
 
 		/*
 		 * if we are not maintaining a random map, we are done.
@@ -167,7 +165,8 @@ static int get_next_rand_offset(struct thread_data *td, struct fio_file *f,
 	 */
 	loops = 10;
 	do {
-		f->last_free_lookup = (f->num_maps - 1) * (r / (RAND_MAX+1.0));
+		f->last_free_lookup = (f->num_maps - 1) *
+					(r / (OS_RAND_MAX + 1.0));
 		if (!get_next_free_block(td, f, ddir, b))
 			return 0;
 
@@ -223,20 +222,30 @@ static int get_next_offset(struct thread_data *td, struct io_u *io_u)
 	return 0;
 }
 
+static inline int is_power_of_2(unsigned int val)
+{
+	return (val != 0 && ((val & (val - 1)) == 0));
+}
+
 static unsigned int get_next_buflen(struct thread_data *td, struct io_u *io_u)
 {
 	const int ddir = io_u->ddir;
-	unsigned int buflen = buflen; /* silence dumb gcc warning */
+	unsigned int uninitialized_var(buflen);
+	unsigned int minbs, maxbs;
 	long r;
 
-	if (td->o.min_bs[ddir] == td->o.max_bs[ddir])
-		buflen = td->o.min_bs[ddir];
+	minbs = td->o.min_bs[ddir];
+	maxbs = td->o.max_bs[ddir];
+
+	if (minbs == maxbs)
+		buflen = minbs;
 	else {
 		r = os_random_long(&td->bsrange_state);
 		if (!td->o.bssplit_nr) {
-			buflen = (unsigned int)
-					(1 + (double) (td->o.max_bs[ddir] - 1)
-					* r / (RAND_MAX + 1.0));
+			buflen = 1 + (unsigned int) ((double) maxbs *
+					(r / (OS_RAND_MAX + 1.0)));
+			if (buflen < minbs)
+				buflen = minbs;
 		} else {
 			long perc = 0;
 			unsigned int i;
@@ -246,20 +255,18 @@ static unsigned int get_next_buflen(struct thread_data *td, struct io_u *io_u)
 
 				buflen = bsp->bs;
 				perc += bsp->perc;
-				if (r <= ((LONG_MAX / 100L) * perc))
+				if (r <= ((OS_RAND_MAX / 100L) * perc))
 					break;
 			}
 		}
-		if (!td->o.bs_unaligned) {
-			buflen = (buflen + td->o.min_bs[ddir] - 1)
-					& ~(td->o.min_bs[ddir] - 1);
-		}
+		if (!td->o.bs_unaligned && is_power_of_2(minbs))
+			buflen = (buflen + minbs - 1) & ~(minbs - 1);
 	}
 
 	if (io_u->offset + buflen > io_u->file->real_file_size) {
 		dprint(FD_IO, "lower buflen %u -> %u (ddir=%d)\n", buflen,
-						td->o.min_bs[ddir], ddir);
-		buflen = td->o.min_bs[ddir];
+						minbs, ddir);
+		buflen = minbs;
 	}
 
 	return buflen;
@@ -284,7 +291,7 @@ static inline enum fio_ddir get_rand_ddir(struct thread_data *td)
 	long r;
 
 	r = os_random_long(&td->rwmix_state);
-	v = 1 + (int) (100.0 * (r / (RAND_MAX + 1.0)));
+	v = 1 + (int) (100.0 * (r / (OS_RAND_MAX + 1.0)));
 	if (v <= td->o.rwmix[DDIR_READ])
 		return DDIR_READ;
 
@@ -315,8 +322,10 @@ static enum fio_ddir get_rw_ddir(struct thread_data *td)
 			max_bytes = td->this_io_bytes[ddir];
 			if (max_bytes >=
 			    (td->o.size * td->o.rwmix[ddir] / 100)) {
-				if (!td->rw_end_set[ddir])
+				if (!td->rw_end_set[ddir]) {
 					td->rw_end_set[ddir] = 1;
+					fio_gettime(&td->rw_end[ddir], NULL);
+				}
 
 				ddir ^= 1;
 			}
@@ -350,8 +359,8 @@ void put_io_u(struct thread_data *td, struct io_u *io_u)
 		put_file_log(td, io_u->file);
 
 	io_u->file = NULL;
-	list_del(&io_u->list);
-	list_add(&io_u->list, &td->io_u_freelist);
+	flist_del(&io_u->list);
+	flist_add(&io_u->list, &td->io_u_freelist);
 	td->cur_depth--;
 }
 
@@ -367,8 +376,8 @@ void requeue_io_u(struct thread_data *td, struct io_u **io_u)
 
 	__io_u->flags &= ~IO_U_F_FLIGHT;
 
-	list_del(&__io_u->list);
-	list_add_tail(&__io_u->list, &td->io_u_requeues);
+	flist_del(&__io_u->list);
+	flist_add_tail(&__io_u->list, &td->io_u_requeues);
 	td->cur_depth--;
 	*io_u = NULL;
 }
@@ -614,7 +623,7 @@ static struct fio_file *get_next_file_rand(struct thread_data *td, int goodf,
 		long r = os_random_long(&td->next_file_state);
 
 		fno = (unsigned int) ((double) td->o.nr_files
-			* (r / (RAND_MAX + 1.0)));
+			* (r / (OS_RAND_MAX + 1.0)));
 		f = td->files[fno];
 		if (f->flags & FIO_FILE_DONE)
 			continue;
@@ -760,10 +769,10 @@ struct io_u *__get_io_u(struct thread_data *td)
 {
 	struct io_u *io_u = NULL;
 
-	if (!list_empty(&td->io_u_requeues))
-		io_u = list_entry(td->io_u_requeues.next, struct io_u, list);
+	if (!flist_empty(&td->io_u_requeues))
+		io_u = flist_entry(td->io_u_requeues.next, struct io_u, list);
 	else if (!queue_full(td)) {
-		io_u = list_entry(td->io_u_freelist.next, struct io_u, list);
+		io_u = flist_entry(td->io_u_freelist.next, struct io_u, list);
 
 		io_u->buflen = 0;
 		io_u->resid = 0;
@@ -776,8 +785,8 @@ struct io_u *__get_io_u(struct thread_data *td)
 		io_u->flags &= ~IO_U_F_FREE;
 
 		io_u->error = 0;
-		list_del(&io_u->list);
-		list_add(&io_u->list, &td->io_u_busylist);
+		flist_del(&io_u->list);
+		flist_add(&io_u->list, &td->io_u_busylist);
 		td->cur_depth++;
 	}
 
@@ -842,7 +851,8 @@ struct io_u *get_io_u(struct thread_data *td)
 
 out:
 	if (!td_io_prep(td, io_u)) {
-		fio_gettime(&io_u->start_time, NULL);
+		if (!td->o.disable_slat)
+			fio_gettime(&io_u->start_time, NULL);
 		return io_u;
 	}
 err_put:
@@ -872,7 +882,11 @@ void io_u_log_error(struct thread_data *td, struct io_u *io_u)
 static void io_completed(struct thread_data *td, struct io_u *io_u,
 			 struct io_completion_data *icd)
 {
-	unsigned long usec;
+	/*
+	 * Older gcc's are too dumb to realize that usec is always used
+	 * initialized, silence that warning.
+	 */
+	unsigned long uninitialized_var(usec);
 
 	dprint_io_u(io_u, "io complete");
 
@@ -895,11 +909,18 @@ static void io_completed(struct thread_data *td, struct io_u *io_u,
 		td->io_bytes[idx] += bytes;
 		td->this_io_bytes[idx] += bytes;
 
-		usec = utime_since(&io_u->issue_time, &icd->time);
+		if (ramp_time_over(td)) {
+			if (!td->o.disable_clat || !td->o.disable_bw)
+				usec = utime_since(&io_u->issue_time,
+							&icd->time);
 
-		add_clat_sample(td, idx, usec);
-		add_bw_sample(td, idx, &icd->time);
-		io_u_mark_latency(td, usec);
+			if (!td->o.disable_clat) {
+				add_clat_sample(td, idx, usec);
+				io_u_mark_latency(td, usec);
+			}
+			if (!td->o.disable_bw)
+				add_bw_sample(td, idx, &icd->time);
+		}
 
 		if (td_write(td) && idx == DDIR_WRITE &&
 		    td->o.do_verify &&
@@ -919,9 +940,11 @@ static void io_completed(struct thread_data *td, struct io_u *io_u,
 	}
 }
 
-static void init_icd(struct io_completion_data *icd, int nr)
+static void init_icd(struct thread_data *td, struct io_completion_data *icd,
+		     int nr)
 {
-	fio_gettime(&icd->time, NULL);
+	if (!td->o.disable_clat || !td->o.disable_bw)
+		fio_gettime(&icd->time, NULL);
 
 	icd->nr = nr;
 
@@ -950,7 +973,7 @@ long io_u_sync_complete(struct thread_data *td, struct io_u *io_u)
 {
 	struct io_completion_data icd;
 
-	init_icd(&icd, 1);
+	init_icd(td, &icd, 1);
 	io_completed(td, io_u, &icd);
 	put_io_u(td, io_u);
 
@@ -964,26 +987,26 @@ long io_u_sync_complete(struct thread_data *td, struct io_u *io_u)
 /*
  * Called to complete min_events number of io for the async engines.
  */
-long io_u_queued_complete(struct thread_data *td, int min_events)
+long io_u_queued_complete(struct thread_data *td, int min_evts)
 {
 	struct io_completion_data icd;
 	struct timespec *tvp = NULL;
 	int ret;
 	struct timespec ts = { .tv_sec = 0, .tv_nsec = 0, };
 
-	dprint(FD_IO, "io_u_queued_completed: min=%d\n", min_events);
+	dprint(FD_IO, "io_u_queued_completed: min=%d\n", min_evts);
 
-	if (!min_events)
+	if (!min_evts)
 		tvp = &ts;
 
-	ret = td_io_getevents(td, min_events, td->cur_depth, tvp);
+	ret = td_io_getevents(td, min_evts, td->o.iodepth_batch_complete, tvp);
 	if (ret < 0) {
 		td_verror(td, -ret, "td_io_getevents");
 		return ret;
 	} else if (!ret)
 		return ret;
 
-	init_icd(&icd, ret);
+	init_icd(td, &icd, ret);
 	ios_completed(td, &icd);
 	if (!icd.error)
 		return icd.bytes_done[0] + icd.bytes_done[1];
@@ -997,10 +1020,12 @@ long io_u_queued_complete(struct thread_data *td, int min_events)
  */
 void io_u_queued(struct thread_data *td, struct io_u *io_u)
 {
-	unsigned long slat_time;
+	if (!td->o.disable_slat) {
+		unsigned long slat_time;
 
-	slat_time = utime_since(&io_u->start_time, &io_u->issue_time);
-	add_slat_sample(td, io_u->ddir, slat_time);
+		slat_time = utime_since(&io_u->start_time, &io_u->issue_time);
+		add_slat_sample(td, io_u->ddir, slat_time);
+	}
 }
 
 /*
@@ -1019,86 +1044,3 @@ void io_u_fill_buffer(struct thread_data *td, struct io_u *io_u,
 	} else
 		memset(ptr, 0, max_bs);
 }
-
-#ifdef FIO_USE_TIMEOUT
-void io_u_set_timeout(struct thread_data *td)
-{
-	assert(td->cur_depth);
-
-	td->timer.it_interval.tv_sec = 0;
-	td->timer.it_interval.tv_usec = 0;
-	td->timer.it_value.tv_sec = IO_U_TIMEOUT + IO_U_TIMEOUT_INC;
-	td->timer.it_value.tv_usec = 0;
-	setitimer(ITIMER_REAL, &td->timer, NULL);
-	fio_gettime(&td->timeout_end, NULL);
-}
-
-static void io_u_dump(struct io_u *io_u)
-{
-	unsigned long t_start = mtime_since_now(&io_u->start_time);
-	unsigned long t_issue = mtime_since_now(&io_u->issue_time);
-
-	log_err("io_u=%p, t_start=%lu, t_issue=%lu\n", io_u, t_start, t_issue);
-	log_err("  buf=%p/%p, len=%lu/%lu, offset=%llu\n", io_u->buf,
-						io_u->xfer_buf, io_u->buflen,
-						io_u->xfer_buflen,
-						io_u->offset);
-	log_err("  ddir=%d, fname=%s\n", io_u->ddir, io_u->file->file_name);
-}
-#else
-void io_u_set_timeout(struct thread_data fio_unused *td)
-{
-}
-#endif
-
-#ifdef FIO_USE_TIMEOUT
-static void io_u_timeout_handler(int fio_unused sig)
-{
-	struct thread_data *td, *__td;
-	pid_t pid = getpid();
-	struct list_head *entry;
-	struct io_u *io_u;
-	int i;
-
-	log_err("fio: io_u timeout\n");
-
-	/*
-	 * TLS would be nice...
-	 */
-	td = NULL;
-	for_each_td(__td, i) {
-		if (__td->pid == pid) {
-			td = __td;
-			break;
-		}
-	}
-
-	if (!td) {
-		log_err("fio: io_u timeout, can't find job\n");
-		exit(1);
-	}
-
-	if (!td->cur_depth) {
-		log_err("fio: timeout without pending work?\n");
-		return;
-	}
-
-	log_err("fio: io_u timeout: job=%s, pid=%d\n", td->o.name, td->pid);
-
-	list_for_each(entry, &td->io_u_busylist) {
-		io_u = list_entry(entry, struct io_u, list);
-
-		io_u_dump(io_u);
-	}
-
-	td_verror(td, ETIMEDOUT, "io_u timeout");
-	exit(1);
-}
-#endif
-
-void io_u_init_timeout(void)
-{
-#ifdef FIO_USE_TIMEOUT
-	signal(SIGALRM, io_u_timeout_handler);
-#endif
-}