/*
* Users are usually interested in average times,
* not accumulated time.
* This also helps us with atomicity problems
* when reading sinlge values.
*/
static inline u64 time_to_avg_nsec(u32 value, u32 count)
{
u64 ret;
/* no samples yet, avoid division by 0 */
if (count == 0)
return 0;
/* value comes in units of 128 µsec */
ret = time_to_nsec(value);
do_div(ret, count);
return ret;
}
void timed_sections_refresh()
{
long long int curr_time = get_time();
if(time_to_nsec(curr_time - last_start[TIMED_SECTION_ALL]) >= 2000000000)
{
time_in_section[TIMED_SECTION_ALL] = curr_time - last_start[TIMED_SECTION_ALL];
DebugMessage(M64MSG_INFO, "gfx=%f%% - audio=%f%% - compiler=%f%%, idle=%f%%",
100.0 * (double)time_in_section[TIMED_SECTION_GFX] / time_in_section[TIMED_SECTION_ALL],
100.0 * (double)time_in_section[TIMED_SECTION_AUDIO] / time_in_section[TIMED_SECTION_ALL],
100.0 * (double)time_in_section[TIMED_SECTION_COMPILER] / time_in_section[TIMED_SECTION_ALL],
100.0 * (double)time_in_section[TIMED_SECTION_IDLE] / time_in_section[TIMED_SECTION_ALL]);
DebugMessage(M64MSG_INFO, "gfx=%llins - audio=%llins - compiler %llins - idle=%llins",
time_to_nsec(time_in_section[TIMED_SECTION_GFX]),
time_to_nsec(time_in_section[TIMED_SECTION_AUDIO]),
time_to_nsec(time_in_section[TIMED_SECTION_COMPILER]),
time_to_nsec(time_in_section[TIMED_SECTION_IDLE]));
time_in_section[TIMED_SECTION_GFX] = 0;
time_in_section[TIMED_SECTION_AUDIO] = 0;
time_in_section[TIMED_SECTION_COMPILER] = 0;
time_in_section[TIMED_SECTION_IDLE] = 0;
last_start[TIMED_SECTION_ALL] = curr_time;
}
}
static inline u64 time_to_avg_nsec(u32 value, u32 count)
{
u64 ret;
/* */
if (count == 0)
return 0;
/* */
ret = time_to_nsec(value);
do_div(ret, count);
return ret;
}
int main(int argc, char *argv[])
{
struct client client;
unsigned int i, j;
struct sockaddr_un addr;
struct timespec start, end;
int fd, wake[2];
char buf;
addr.sun_family = AF_UNIX;
sprintf(addr.sun_path, "/tmp/run-different-speed.sock.%u", getpid());
if (pipe(wake) != 0 || pipe(timeout) != 0)
err(1, "Creating pipes");
fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd < 0)
err(1, "Creating socket");
if (bind(fd, (void *)&addr, sizeof(addr)) != 0)
err(1, "Binding to %s", addr.sun_path);
if (listen(fd, NUM_CONNS) != 0)
err(1, "Listening on %s", addr.sun_path);
for (i = 0; i < NUM_CHILDREN; i++) {
switch (fork()) {
case -1:
err(1, "forking");
case 0:
close(wake[1]);
create_clients(&addr, wake[0]);
break;
}
for (j = 0; j < NUM_CONNS; j++) {
int ret = accept(fd, NULL, 0);
if (ret < 0)
err(1, "Accepting fd");
/* For efficiency, we share client structure */
io_new_conn(ret,
io_read(client.request_buffer, REQUEST_SIZE,
write_reply, &client));
}
}
io_new_conn(timeout[0], io_read(&buf, 1, do_timeout, &buf));
close(wake[0]);
for (i = 0; i < NUM_CHILDREN; i++)
write(wake[1], "1", 1);
signal(SIGALRM, sigalarm);
alarm(10);
start = time_now();
io_loop();
end = time_now();
close(fd);
printf("%u connections complete (%u ns per conn)\n",
completed,
(int)time_to_nsec(time_divide(time_sub(end, start), completed)));
return 0;
}
int main(void)
{
struct timespec t1, t2, t3, zero = { 0, 0 };
plan_tests(61);
/* Test time_now */
t1 = time_now();
t2 = time_now();
/* Test time_sub. */
t3 = time_sub(t2, t1);
ok1(t3.tv_sec > 0 || t3.tv_nsec >= 0);
t3 = time_sub(t2, t2);
ok1(t3.tv_sec == 0 && t3.tv_nsec == 0);
t3 = time_sub(t1, t1);
ok1(t3.tv_sec == 0 && t3.tv_nsec == 0);
/* Test time_eq */
ok1(time_eq(t1, t1));
ok1(time_eq(t2, t2));
ok1(!time_eq(t1, t3));
ok1(!time_eq(t2, t3));
/* Make sure t2 > t1. */
t3.tv_sec = 0;
t3.tv_nsec = 1;
t2 = time_add(t2, t3);
/* Test time_less and time_greater. */
ok1(!time_eq(t1, t2));
ok1(!time_greater(t1, t2));
ok1(time_less(t1, t2));
ok1(time_greater(t2, t1));
ok1(!time_less(t2, t1));
t3.tv_sec = 0;
t3.tv_nsec = 999999999;
t2 = time_add(t2, t3);
ok1(!time_eq(t1, t2));
ok1(!time_greater(t1, t2));
ok1(time_less(t1, t2));
ok1(time_greater(t2, t1));
ok1(!time_less(t2, t1));
t3 = time_sub(t2, zero);
ok1(time_eq(t3, t2));
t3 = time_sub(t2, t2);
ok1(time_eq(t3, zero));
/* time_from_sec / time_to_sec */
t3 = time_from_sec(500);
ok1(t3.tv_sec == 500);
ok1(t3.tv_nsec == 0);
ok1(time_to_sec(t3) == 500);
/* time_from_msec / time_to_msec */
t3 = time_from_msec(500);
ok1(t3.tv_sec == 0);
ok1(t3.tv_nsec == 500000000);
ok1(time_to_msec(t3) == 500);
t3 = time_from_msec(1000);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 0);
ok1(time_to_msec(t3) == 1000);
t3 = time_from_msec(1500);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 500000000);
ok1(time_to_msec(t3) == 1500);
/* time_from_usec */
t3 = time_from_usec(500000);
ok1(t3.tv_sec == 0);
ok1(t3.tv_nsec == 500000000);
ok1(time_to_usec(t3) == 500000);
t3 = time_from_usec(1000000);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 0);
ok1(time_to_usec(t3) == 1000000);
t3 = time_from_usec(1500000);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 500000000);
ok1(time_to_usec(t3) == 1500000);
/* time_from_nsec */
t3 = time_from_nsec(500000000);
ok1(t3.tv_sec == 0);
ok1(t3.tv_nsec == 500000000);
ok1(time_to_nsec(t3) == 500000000);
t3 = time_from_nsec(1000000000);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 0);
ok1(time_to_nsec(t3) == 1000000000);
t3 = time_from_nsec(1500000000);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 500000000);
ok1(time_to_nsec(t3) == 1500000000);
/* Test wrapunder */
t3 = time_sub(time_sub(t2, time_from_msec(500)), time_from_msec(500));
ok1(t3.tv_sec == t2.tv_sec - 1);
ok1(t3.tv_nsec == t2.tv_nsec);
/* time_divide and time_multiply */
t1.tv_nsec = 100;
t1.tv_sec = 100;
t3 = time_divide(t1, 2);
ok1(t3.tv_sec == 50);
ok1(t3.tv_nsec == 50);
t3 = time_divide(t1, 100);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 1);
t3 = time_multiply(t3, 100);
ok1(time_eq(t3, t1));
t3 = time_divide(t1, 200);
ok1(t3.tv_sec == 0);
ok1(t3.tv_nsec == 500000000);
/* Divide by huge number. */
t1.tv_sec = (1U << 31) - 1;
t1.tv_nsec = 999999999;
t2 = time_divide(t1, 1 << 30);
/* Allow us to round either way. */
ok1((t2.tv_sec == 2 && t2.tv_nsec == 0)
|| (t2.tv_sec == 1 && t2.tv_nsec == 999999999));
/* Multiply by huge number. */
t1.tv_sec = 0;
t1.tv_nsec = 1;
t2 = time_multiply(t1, 1UL << 31);
ok1(t2.tv_sec == 2);
ok1(t2.tv_nsec == 147483648);
return exit_status();
}
/* Nanoseconds per operation */
static size_t normalize(const struct timeabs *start,
const struct timeabs *stop,
unsigned int num)
{
return time_to_nsec(time_divide(time_between(*stop, *start), num));
}
