Major change in API for creating sources to handle multiple main loops

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)

tests/timeloop-basic.c

@@ -0,0 +1,232 @@
+#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;
+}
+