[fio.git] / time.c

#include <time.h>
#include <sys/time.h>

#include "fio.h"

static struct timeval genesis;
static unsigned long ns_granularity;

unsigned long long utime_since(struct timeval *s, struct timeval *e)
{
	long sec, usec;
	unsigned long long ret;

	sec = e->tv_sec - s->tv_sec;
	usec = e->tv_usec - s->tv_usec;
	if (sec > 0 && usec < 0) {
		sec--;
		usec += 1000000;
	}

	/*
	 * time warp bug on some kernels?
	 */
	if (sec < 0 || (sec == 0 && usec < 0))
		return 0;

	ret = sec * 1000000ULL + usec;

	return ret;
}

unsigned long long utime_since_now(struct timeval *s)
{
	struct timeval t;

	fio_gettime(&t, NULL);
	return utime_since(s, &t);
}

unsigned long mtime_since(struct timeval *s, struct timeval *e)
{
	long sec, usec, ret;

	sec = e->tv_sec - s->tv_sec;
	usec = e->tv_usec - s->tv_usec;
	if (sec > 0 && usec < 0) {
		sec--;
		usec += 1000000;
	}

	if (sec < 0 || (sec == 0 && usec < 0))
		return 0;

	sec *= 1000UL;
	usec /= 1000UL;
	ret = sec + usec;

	return ret;
}

unsigned long mtime_since_now(struct timeval *s)
{
	struct timeval t;
	void *p = __builtin_return_address(0);

	fio_gettime(&t, p);
	return mtime_since(s, &t);
}

unsigned long time_since_now(struct timeval *s)
{
	return mtime_since_now(s) / 1000;
}

/*
 * busy looping version for the last few usec
 */
void usec_spin(unsigned int usec)
{
	struct timeval start;

	fio_gettime(&start, NULL);
	while (utime_since_now(&start) < usec)
		nop;
}

void usec_sleep(struct thread_data *td, unsigned long usec)
{
	struct timespec req;
	struct timeval tv;

	do {
		unsigned long ts = usec;

		if (usec < ns_granularity) {
			usec_spin(usec);
			break;
		}

		ts = usec - ns_granularity;

		if (ts >= 1000000) {
			req.tv_sec = ts / 1000000;
			ts -= 1000000 * req.tv_sec;
		} else
			req.tv_sec = 0;

		req.tv_nsec = ts * 1000;
		fio_gettime(&tv, NULL);

		if (nanosleep(&req, NULL) < 0)
			break;

		ts = utime_since_now(&tv);
		if (ts >= usec)
			break;

		usec -= ts;
	} while (!td->terminate);
}

unsigned long mtime_since_genesis(void)
{
	return mtime_since_now(&genesis);
}

int in_ramp_time(struct thread_data *td)
{
	return td->o.ramp_time && !td->ramp_time_over;
}

int ramp_time_over(struct thread_data *td)
{
	struct timeval tv;

	if (!td->o.ramp_time || td->ramp_time_over)
		return 1;

	fio_gettime(&tv, NULL);
	if (mtime_since(&td->epoch, &tv) >= td->o.ramp_time * 1000) {
		td->ramp_time_over = 1;
		reset_all_stats(td);
		td_set_runstate(td, TD_RAMP);
		return 1;
	}

	return 0;
}

void fio_time_init(void)
{
	int i;

	fio_clock_init();

	/*
	 * Check the granularity of the nanosleep function
	 */
	for (i = 0; i < 10; i++) {
		struct timeval tv;
		struct timespec ts;
		unsigned long elapsed;

		fio_gettime(&tv, NULL);
		ts.tv_sec = 0;
		ts.tv_nsec = 1000;

		nanosleep(&ts, NULL);
		elapsed = utime_since_now(&tv);

		if (elapsed > ns_granularity)
			ns_granularity = elapsed;
	}
}

void set_genesis_time(void)
{
	fio_gettime(&genesis, NULL);
}

void fill_start_time(struct timeval *t)
{
	memcpy(t, &genesis, sizeof(genesis));
}
Commit	Line	Data
3c39a379 JA	1	#include <time.h>
	2	#include <sys/time.h>
	3
	4	#include "fio.h"
	5
263e529f	6	static struct timeval genesis;
fd841467	7	static unsigned long ns_granularity;
263e529f	8
10927316	9	unsigned long long utime_since(struct timeval s, struct timeval e)
3c39a379	10	{
10927316 SL	11	long sec, usec;
10927316 SL	12	unsigned long long ret;
5ec10eaa	13
3c39a379 JA	14	sec = e->tv_sec - s->tv_sec;
	15	usec = e->tv_usec - s->tv_usec;
	16	if (sec > 0 && usec < 0) {
	17	sec--;
	18	usec += 1000000;
	19	}
	20
2bfe24bd JA	21	/*
	22	* time warp bug on some kernels?
	23	*/
10927316 SL	24	if (sec < 0 \|\| (sec == 0 && usec < 0))
10927316 SL	25	return 0;
5ec10eaa	26
10927316	27	ret = sec * 1000000ULL + usec;
5ec10eaa	28
2bfe24bd	29	return ret;
3c39a379 JA	30	}
3c39a379 JA	31
10927316	32	unsigned long long utime_since_now(struct timeval *s)
3c39a379 JA	33	{
	34	struct timeval t;
	35
02bcaa8c	36	fio_gettime(&t, NULL);
3c39a379 JA	37	return utime_since(s, &t);
	38	}
	39
	40	unsigned long mtime_since(struct timeval s, struct timeval e)
	41	{
2bfe24bd	42	long sec, usec, ret;
3c39a379 JA	43
	44	sec = e->tv_sec - s->tv_sec;
	45	usec = e->tv_usec - s->tv_usec;
	46	if (sec > 0 && usec < 0) {
	47	sec--;
	48	usec += 1000000;
	49	}
	50
c03b373d JA	51	if (sec < 0 \|\| (sec == 0 && usec < 0))
	52	return 0;
	53
64b18e12 JA	54	sec *= 1000UL;
64b18e12 JA	55	usec /= 1000UL;
2bfe24bd JA	56	ret = sec + usec;
2bfe24bd JA	57
2bfe24bd	58	return ret;
3c39a379 JA	59	}
	60
	61	unsigned long mtime_since_now(struct timeval *s)
	62	{
	63	struct timeval t;
02bcaa8c	64	void *p = __builtin_return_address(0);
3c39a379	65
02bcaa8c	66	fio_gettime(&t, p);
3c39a379 JA	67	return mtime_since(s, &t);
	68	}
	69
	70	unsigned long time_since_now(struct timeval *s)
	71	{
	72	return mtime_since_now(s) / 1000;
	73	}
	74
	75	/*
	76	* busy looping version for the last few usec
	77	*/
6dd6f2cd	78	void usec_spin(unsigned int usec)
3c39a379 JA	79	{
	80	struct timeval start;
	81
02bcaa8c	82	fio_gettime(&start, NULL);
3c39a379 JA	83	while (utime_since_now(&start) < usec)
	84	nop;
	85	}
	86
	87	void usec_sleep(struct thread_data *td, unsigned long usec)
	88	{
fd841467 JA	89	struct timespec req;
fd841467 JA	90	struct timeval tv;
3c39a379 JA	91
3c39a379 JA	92	do {
fd841467 JA	93	unsigned long ts = usec;
	94
	95	if (usec < ns_granularity) {
6dd6f2cd	96	usec_spin(usec);
3c39a379 JA	97	break;
	98	}
	99
fd841467	100	ts = usec - ns_granularity;
3c39a379	101
fd841467 JA	102	if (ts >= 1000000) {
	103	req.tv_sec = ts / 1000000;
	104	ts -= 1000000 * req.tv_sec;
	105	} else
	106	req.tv_sec = 0;
	107
	108	req.tv_nsec = ts * 1000;
	109	fio_gettime(&tv, NULL);
	110
	111	if (nanosleep(&req, NULL) < 0)
3c39a379 JA	112	break;
3c39a379 JA	113
fd841467 JA	114	ts = utime_since_now(&tv);
	115	if (ts >= usec)
	116	break;
3c39a379	117
fd841467	118	usec -= ts;
3c39a379 JA	119	} while (!td->terminate);
	120	}
	121
263e529f JA	122	unsigned long mtime_since_genesis(void)
	123	{
	124	return mtime_since_now(&genesis);
	125	}
	126
b29ee5b3 JA	127	int in_ramp_time(struct thread_data *td)
	128	{
	129	return td->o.ramp_time && !td->ramp_time_over;
	130	}
	131
721938ae JA	132	int ramp_time_over(struct thread_data *td)
	133	{
	134	struct timeval tv;
	135
	136	if (!td->o.ramp_time \|\| td->ramp_time_over)
	137	return 1;
	138
	139	fio_gettime(&tv, NULL);
	140	if (mtime_since(&td->epoch, &tv) >= td->o.ramp_time * 1000) {
	141	td->ramp_time_over = 1;
b29ee5b3 JA	142	reset_all_stats(td);
b29ee5b3 JA	143	td_set_runstate(td, TD_RAMP);
721938ae JA	144	return 1;
	145	}
	146
	147	return 0;
	148	}
	149
03e20d68	150	void fio_time_init(void)
263e529f	151	{
fd841467 JA	152	int i;
fd841467 JA	153
c223da83 JA	154	fio_clock_init();
c223da83 JA	155
fd841467 JA	156	/*
	157	* Check the granularity of the nanosleep function
	158	*/
	159	for (i = 0; i < 10; i++) {
	160	struct timeval tv;
	161	struct timespec ts;
	162	unsigned long elapsed;
	163
	164	fio_gettime(&tv, NULL);
	165	ts.tv_sec = 0;
	166	ts.tv_nsec = 1000;
	167
	168	nanosleep(&ts, NULL);
	169	elapsed = utime_since_now(&tv);
	170
	171	if (elapsed > ns_granularity)
	172	ns_granularity = elapsed;
	173	}
263e529f	174	}
6043c579	175
a2f77c9f JA	176	void set_genesis_time(void)
	177	{
	178	fio_gettime(&genesis, NULL);
	179	}
	180
6043c579 JA	181	void fill_start_time(struct timeval *t)
	182	{
	183	memcpy(t, &genesis, sizeof(genesis));
	184	}