glib/timeloop-basic.c

233 lines
4.1 KiB
C
Raw Normal View History

#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/resource.h>
#include <sys/time.h>
#include <sys/poll.h>
#define TRUE 1
#define FALSE 0
static int n_children = 3;
static int n_active_children;
static int n_iters = 10000;
static int write_fds[1024];
static struct pollfd poll_fds[1024];
void
my_pipe (int *fds)
{
if (pipe(fds) < 0)
{
fprintf (stderr, "Cannot create pipe %s\n", strerror (errno));
exit (1);
}
}
int
read_all (int fd, char *buf, int len)
{
int bytes_read = 0;
int count;
while (bytes_read < len)
{
count = read (fd, buf + bytes_read, len - bytes_read);
if (count < 0)
{
if (errno != EAGAIN)
return FALSE;
}
else if (count == 0)
return FALSE;
bytes_read += count;
}
return TRUE;
}
int
write_all (int fd, char *buf, int len)
{
int bytes_written = 0;
int count;
while (bytes_written < len)
{
count = write (fd, buf + bytes_written, len - bytes_written);
if (count < 0)
{
if (errno != EAGAIN)
return FALSE;
}
bytes_written += count;
}
return TRUE;
}
void
run_child (int in_fd, int out_fd)
{
int i;
int val = 1;
for (i = 0; i < n_iters; i++)
{
write_all (out_fd, (char *)&val, sizeof (val));
read_all (in_fd, (char *)&val, sizeof (val));
}
val = 0;
write_all (out_fd, (char *)&val, sizeof (val));
exit (0);
}
int
input_callback (int source, int dest)
{
int val;
if (!read_all (source, (char *)&val, sizeof(val)))
{
fprintf (stderr,"Unexpected EOF\n");
exit (1);
}
if (val)
{
write_all (dest, (char *)&val, sizeof(val));
return TRUE;
}
else
{
close (source);
close (dest);
n_active_children--;
return FALSE;
}
}
void
create_child (int pos)
{
int pid;
int in_fds[2];
int out_fds[2];
my_pipe (in_fds);
my_pipe (out_fds);
pid = fork ();
if (pid > 0) /* Parent */
{
close (in_fds[0]);
close (out_fds[1]);
write_fds[pos] = in_fds[1];
poll_fds[pos].fd = out_fds[0];
poll_fds[pos].events = POLLIN;
}
else if (pid == 0) /* Child */
{
close (in_fds[1]);
close (out_fds[0]);
setsid ();
run_child (in_fds[0], out_fds[1]);
}
else /* Error */
{
fprintf (stderr,"Cannot fork: %s\n", strerror (errno));
exit (1);
}
}
static double
difftimeval (struct timeval *old, struct timeval *new)
{
return
(new->tv_sec - old->tv_sec) * 1000. + (new->tv_usec - old->tv_usec) / 1000;
}
int
main (int argc, char **argv)
{
int i, j;
struct rusage old_usage;
struct rusage new_usage;
if (argc > 1)
n_children = atoi(argv[1]);
if (argc > 2)
n_iters = atoi(argv[2]);
printf ("Children: %d Iters: %d\n", n_children, n_iters);
n_active_children = n_children;
for (i = 0; i < n_children; i++)
create_child (i);
getrusage (RUSAGE_SELF, &old_usage);
while (n_active_children > 0)
{
int old_n_active_children = n_active_children;
poll (poll_fds, n_active_children, -1);
for (i=0; i<n_active_children; i++)
{
if (poll_fds[i].events & (POLLIN | POLLHUP))
{
if (!input_callback (poll_fds[i].fd, write_fds[i]))
write_fds[i] = -1;
}
}
if (old_n_active_children > n_active_children)
{
j = 0;
for (i=0; i<old_n_active_children; i++)
{
if (write_fds[i] != -1)
{
if (j < i)
{
poll_fds[j] = poll_fds[i];
write_fds[j] = write_fds[i];
}
j++;
}
}
}
}
getrusage (RUSAGE_SELF, &new_usage);
printf ("Elapsed user: %g\n",
difftimeval (&old_usage.ru_utime, &new_usage.ru_utime));
printf ("Elapsed system: %g\n",
difftimeval (&old_usage.ru_stime, &new_usage.ru_stime));
printf ("Elapsed total: %g\n",
difftimeval (&old_usage.ru_utime, &new_usage.ru_utime) +
difftimeval (&old_usage.ru_stime, &new_usage.ru_stime));
printf ("total / iteration: %g\n",
(difftimeval (&old_usage.ru_utime, &new_usage.ru_utime) +
difftimeval (&old_usage.ru_stime, &new_usage.ru_stime)) /
(n_iters * n_children));
return 0;
}