adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-27 19:26:25 +00:00
Code Issues Projects Releases Packages Wiki Activity

ring-buffer: change test to be more latency friendly

Browse source 
The ring buffer benchmark/test runs a producer for 10 seconds.
This is done with preemption and interrupts enabled. But if the kernel
is not compiled with CONFIG_PREEMPT, it basically stops everything
but interrupts for 10 seconds.

Although this is just a test and is not for production, this attribute
can be quite annoying. It can also spawn badness elsewhere.

This patch solves the issues by calling "cond_resched" when the system
is not compiled with CONFIG_PREEMPT. It also keeps track of the time
spent to call cond_resched such that it does not go against the
time calculations. That is, if the task schedules away, the time scheduled
out is removed from the test data. Note, this only works for non PREEMPT
because we do not know when the task is scheduled out if we have PREEMPT
enabled.

[ Impact: prevent test from stopping the world for 10 seconds ]

Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
This commit is contained in:
Steven Rostedt 2009-05-06 18:36:59 -04:00 committed by Steven Rostedt
parent 6634ff26cc
commit 3e07a4f680
1 changed files with 31 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
kernel/trace/ring_buffer_benchmark.c
View file

@ -185,6 +185,35 @@ static void ring_buffer_consumer(void)
complete(&read_done);
}
/*
* If we are a non preempt kernel, the 10 second run will
* stop everything while it runs. Instead, we will call cond_resched
* and also add any time that was lost by a rescedule.
*/
#ifdef CONFIG_PREEMPT
static void sched_if_needed(struct timeval *start_tv, struct timeval *end_tv)
{
}
#else
static void sched_if_needed(struct timeval *start_tv, struct timeval *end_tv)
{
struct timeval tv;
cond_resched();
do_gettimeofday(&tv);
if (tv.tv_usec < end_tv->tv_usec) {
tv.tv_usec += 1000000;
tv.tv_sec--;
}
start_tv->tv_sec += tv.tv_sec - end_tv->tv_sec;
start_tv->tv_usec += tv.tv_usec - end_tv->tv_usec;
if (start_tv->tv_usec > 1000000) {
start_tv->tv_usec -= 1000000;
start_tv->tv_sec++;
}
}
#endif
static void ring_buffer_producer(void)
{
struct timeval start_tv;
@ -221,6 +250,8 @@ static void ring_buffer_producer(void)
if (consumer && !(++cnt % wakeup_interval))
wake_up_process(consumer);
sched_if_needed(&start_tv, &end_tv);
} while (end_tv.tv_sec < (start_tv.tv_sec + RUN_TIME) && !kill_test);
pr_info("End ring buffer hammer\n");