mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-10 19:36:18 +01:00
e2fd4e2bd0
Tue Dec 5 12:23:04 2000 Owen Taylor <otaylor@redhat.com> * gmain.[hc]: Major change in API for creating sources to handle multiple main loops (GMainContext *). GSources are now exposed as GSource * and implemented with structure derivation. * giochannel.[ch]: Changed vtable for GIOChannel to correspond to the new mainloop API, add g_io_channel_create_watch(). * gtypes.h: Move GTimeVal here. * gthread.h: Remove gmain.h include to avoid circularity. * giounix.c: Update for new GMain API. * giowin32.c: Update for new GMain API. (No check for proper compilation or working.) * timeloop.c timeloop-basic.c: A benchmarking program for the main loop comparing the main loop against a hand-written (timeloop-basic.c) variant. * tests/mainloop-test.c: New torture test of mainloop. * docs/Changes-2.0.txt: Started. Added text about changes to GMain. * gmain.c (g_main_add_poll_unlocked): Initial fd->revents to zero. (#8482, Benjamin Kahn)
233 lines
4.1 KiB
C
233 lines
4.1 KiB
C
#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;
|
|
}
|
|
|