/* Unit test for W32 version of g_poll()

 *

 * Copyright © 2017 Руслан Ижбулатов <lrn1986@gmail.com>

 *

 * This is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#include <glib.h>

#include <Winsock2.h>

#define NUM_POLLEES 63

#define NUM_POLLFDS 64

#define ASYNC_CONNECT_OK(r) (r == 0 || (r < 0 && GetLastError () == WSAEWOULDBLOCK))

#define REPEAT 1000

static void

init_networking (void)

{

  WSADATA wsadata;

  if (WSAStartup (MAKEWORD (2, 0), &wsadata) != 0)

    g_error ("Windows Sockets could not be initialized");

}

static void

prepare_fds (SOCKET  sockets[],

             GPollFD fds[],

             int     num_pollees)

{

  gint i;

  for (i = 0; i < num_pollees; i++)

    {

      fds[i].fd = (gintptr) WSACreateEvent ();

      g_assert (WSAEventSelect (sockets[i], (HANDLE) fds[i].fd, FD_READ | FD_CLOSE) == 0);

    }

}

static void

reset_fds (GPollFD fds[],

           int     num_pollees)

{

  gint i;

  for (i = 0; i < num_pollees; i++)

    {

      WSAResetEvent ((HANDLE) fds[i].fd);

      fds[i].events =  G_IO_IN | G_IO_OUT | G_IO_ERR;

      fds[i].revents = 0;

    }

}

static void

reset_fds_msg (GPollFD fds[],

               int     num_pollfds)

{

  fds[num_pollfds - 1].fd = G_WIN32_MSG_HANDLE;

  fds[num_pollfds - 1].events = G_IO_IN;

  fds[num_pollfds - 1].revents = 0;

}

static void

check_fds (SOCKET  sockets[],

           GPollFD fds[],

           int     num_pollees)

{

  gint i;

  for (i = 0; i < num_pollees; i++)

    {

      if (fds[i].revents != 0)

        {

          WSANETWORKEVENTS events;

          g_assert (WSAEnumNetworkEvents (sockets[i], 0, &events) == 0);

          fds[i].revents = 0;

          if (events.lNetworkEvents & (FD_READ | FD_ACCEPT))

            fds[i].revents |= G_IO_IN;

          if (events.lNetworkEvents & FD_WRITE)

            fds[i].revents |= G_IO_OUT;

          else

            {

              /* We have called WSAEnumNetworkEvents() above but it didn't

               * set FD_WRITE.

               */

              if (events.lNetworkEvents & FD_CONNECT)

                {

                  if (events.iErrorCode[FD_CONNECT_BIT] == 0)

                    fds[i].revents |= G_IO_OUT;

                  else

                    fds[i].revents |= (G_IO_HUP | G_IO_ERR);

                }

              if (fds[i].revents == 0 && (events.lNetworkEvents & (FD_CLOSE)))

                fds[i].revents |= G_IO_HUP;

            }

        }

    }

}

static void

prepare_sockets (SOCKET  sockets[],

                 SOCKET  opp_sockets[],

                 GPollFD fds[],

                 int     num_pollees)

{

  gint i;

  SOCKET server;

  struct sockaddr_in sa;

  unsigned long ul = 1;

  int sa_size;

  int r;

  server = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);

  g_assert (server != INVALID_SOCKET);

  memset(&sa, 0, sizeof sa);

  sa.sin_family = AF_INET;

  sa.sin_port = 0;

  sa.sin_addr.s_addr = htonl (INADDR_LOOPBACK);

  sa_size = sizeof (sa);

  g_assert (bind (server, (const struct sockaddr *) &sa, sa_size) == 0);

  g_assert (getsockname (server, (struct sockaddr *) &sa, &sa_size) == 0);

  g_assert (listen (server, 1) == 0);

  for (i = 0; i < num_pollees; i++)

    {

      opp_sockets[i] = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);

      g_assert (opp_sockets[i] != INVALID_SOCKET);

      g_assert (ioctlsocket (opp_sockets[i], FIONBIO, &ul) == 0);

      r = connect (opp_sockets[i], (const struct sockaddr *) &sa, sizeof (sa));

      g_assert (ASYNC_CONNECT_OK (r));

      sockets[i] = accept (server, NULL, NULL);

      g_assert (sockets[i] != INVALID_SOCKET);

      g_assert (ioctlsocket (sockets[i], FIONBIO, &ul) == 0);

    }

  closesocket (server);

}

static void

cleanup_sockets (SOCKET sockets[],

                 SOCKET opp_sockets[],

                 int    num_pollees)

{

  gint i;

  for (i = 0; i < num_pollees; i++)

    {

      closesocket (sockets[i]);

      closesocket (opp_sockets[i]);

    }

}

static void

bucketize (gint64 val,

           gint   buckets[],

           gint64 bucket_limits[],

           gint   count)

{

  gint i;

  if (val > bucket_limits[count - 1])

    {

      buckets[count - 1] += 1;

      return;

    }

  for (i = count - 1; i > 0; i--)

    if (val < bucket_limits[i] && val >= bucket_limits[i - 1])

      {

        buckets[i] += 1;

        return;

      }

  buckets[0] += 1;

}

static void

print_buckets (gint   buckets[],

               gint64 bucket_limits[],

               gint   count)

{

  gint i;

  for (i = 0; i < count; i++)

    if (i < count - 1)

      g_print ("%-4lld-%4lld|", i == 0 ? 0 : bucket_limits[i - 1], bucket_limits[i] - 1);

    else

      g_print ("  >= %-4lld|", bucket_limits[i - 1]);

  g_print ("\n");

  for (i = 0; i < count; i++)

    {

      gint len;

      gint padding;

      gint j;

      if (buckets[i] < 10)

        len = 1;

      else if (buckets[i] < 100)

        len = 2;

      else if (buckets[i] < 1000)

        len = 3;

      else

        len = 4;

      padding = 9 - len;

      for (j = 0; j < padding / 2; j++)

        g_print (" ");

      if (buckets[i] != 0)

        g_print ("%*d", len, buckets[i]);

      else

        g_print (" ");

      for (j = padding / 2; j < padding; j++)

        g_print (" ");

      g_print (" ");

    }

  g_print ("\n\n");

}

static void

test_gpoll (void)

{

  SOCKET sockets[NUM_POLLEES];

  GPollFD fds[NUM_POLLFDS];

  SOCKET opp_sockets[NUM_POLLEES];

  gint i;

  gint activatable;

  gint64 times[REPEAT][2];

#define BUCKET_COUNT 25

  gint64 bucket_limits[BUCKET_COUNT] = {3, 5, 10, 15, 20, 25, 30, 35, 40, 50, 60, 70, 80, 90, 100, 120, 150, 180, 220, 280, 350, 450, 600, 800, 1000};

  gint   buckets[BUCKET_COUNT];

  gint64 times_avg = 0, times_min = G_MAXINT64, times_max = 0;

  prepare_sockets (sockets, opp_sockets, fds, NUM_POLLEES);

  prepare_fds (sockets, fds, NUM_POLLEES);

  times_avg = 0;

  times_min = G_MAXINT64;

  times_max = 0;

  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);

  for (i = 0; i < REPEAT; i++)

    {

      gint r;

      gint64 diff;

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      times[i][0] = g_get_monotonic_time ();

      r = g_poll (fds, NUM_POLLFDS, 0);

      times[i][1] = g_get_monotonic_time ();

      g_assert (r == 0);

      diff = times[i][1] - times[i][0];

      if (times_min > diff)

        times_min = diff;

      if (times_max < diff)

        times_max = diff;

      times_avg += diff;

      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);

    }

  times_avg /= NUM_POLLEES;

  g_print ("\nempty poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);

  print_buckets (buckets, bucket_limits, BUCKET_COUNT);

  times_avg = 0;

  times_min = G_MAXINT64;

  times_max = 0;

  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);

  activatable = 0;

  for (i = 0; i < REPEAT; i++)

    {

      gint r, s, v, t;

      gint64 diff;

      MSG msg;

      gboolean found_app;

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      s = send (opp_sockets[activatable], (const char *) &t, 1, 0);

      g_assert (PostMessage (NULL, WM_APP, 1, 2));

      /* This is to ensure that all sockets catch up, otherwise some might not poll active */

      g_usleep (G_USEC_PER_SEC / 1000);

      times[i][0] = g_get_monotonic_time ();

      r = g_poll (fds, NUM_POLLFDS, 1000);

      times[i][1] = g_get_monotonic_time ();

      check_fds (sockets, fds, NUM_POLLEES);

      v = recv (sockets[activatable], (char *) &t, 1, 0);

      found_app = FALSE;

      while (!found_app && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))

        if (msg.message == WM_APP && msg.wParam == 1 && msg.lParam == 2)

          found_app = TRUE;

      g_assert (s == 1);

      g_assert (r == 2);

      g_assert (v == 1);

      g_assert (found_app);

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      r = g_poll (fds, NUM_POLLFDS, 0);

      check_fds (sockets, fds, NUM_POLLEES);

      g_assert (r == 0);

      diff = times[i][1] - times[i][0];

      if (times_min > diff)

        times_min = diff;

      if (times_max < diff)

        times_max = diff;

      times_avg += diff;

      activatable = (activatable + 1) % NUM_POLLEES;

      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);

    }

  times_avg /= NUM_POLLEES;

  g_print ("1-socket + msg poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);

  print_buckets (buckets, bucket_limits, BUCKET_COUNT);

  times_avg = 0;

  times_min = G_MAXINT64;

  times_max = 0;

  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);

  activatable = 0;

  for (i = 0; i < REPEAT; i++)

    {

      gint r, s, v, t;

      gint64 diff;

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      s = send (opp_sockets[activatable], (const char *) &t, 1, 0);

      g_usleep (G_USEC_PER_SEC / 1000);

      times[i][0] = g_get_monotonic_time ();

      r = g_poll (fds, NUM_POLLFDS, 1000);

      times[i][1] = g_get_monotonic_time ();

      check_fds (sockets, fds, NUM_POLLEES);

      v = recv (sockets[activatable], (char *) &t, 1, 0);

      g_assert (s == 1);

      g_assert (r == 1);

      g_assert (v == 1);

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      r = g_poll (fds, NUM_POLLFDS, 0);

      check_fds (sockets, fds, NUM_POLLEES);

      g_assert (r == 0);

      diff = times[i][1] - times[i][0];

      if (times_min > diff)

        times_min = diff;

      if (times_max < diff)

        times_max = diff;

      times_avg += diff;

      activatable = (activatable + 1) % NUM_POLLEES;

      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);

    }

  times_avg /= NUM_POLLEES;

  g_print ("1-socket poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);

  print_buckets (buckets, bucket_limits, BUCKET_COUNT);

  times_avg = 0;

  times_min = G_MAXINT64;

  times_max = 0;

  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);

  for (i = 0; i < REPEAT; i++)

    {

      gint r, s, v, t;

      gint64 diff;

      gint j;

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      s = v = 0;

      for (j = 0; j < NUM_POLLEES / 2; j++)

        s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0;

      g_usleep (G_USEC_PER_SEC / 1000);

      times[i][0] = g_get_monotonic_time ();

      r = g_poll (fds, NUM_POLLFDS, 1000);

      times[i][1] = g_get_monotonic_time ();

      check_fds (sockets, fds, NUM_POLLEES);

      for (j = 0; j < NUM_POLLEES / 2; j++)

        v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0;

      g_assert (s == NUM_POLLEES / 2);

      g_assert (r == NUM_POLLEES / 2);

      g_assert (v == NUM_POLLEES / 2);

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      r = g_poll (fds, NUM_POLLFDS, 0);

      check_fds (sockets, fds, NUM_POLLEES);

      g_assert (r == 0);

      diff = times[i][1] - times[i][0];

      if (times_min > diff)

        times_min = diff;

      if (times_max < diff)

        times_max = diff;

      times_avg += diff;

      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);

    }

  times_avg /= NUM_POLLEES;

  g_print ("half-socket poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);

  print_buckets (buckets, bucket_limits, BUCKET_COUNT);

  times_avg = 0;

  times_min = G_MAXINT64;

  times_max = 0;

  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);

  for (i = 0; i < REPEAT; i++)

    {

      gint r, s, v, t;

      gint64 diff;

      gint j;

      MSG msg;

      gboolean found_app;

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      s = v = 0;

      for (j = 0; j < NUM_POLLEES / 2; j++)

        s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0;

      g_assert (PostMessage (NULL, WM_APP, 1, 2));

      /* This is to ensure that all sockets catch up, otherwise some might not poll active */

      g_usleep (G_USEC_PER_SEC / 1000);

      times[i][0] = g_get_monotonic_time ();

      r = g_poll (fds, NUM_POLLFDS, 1000);

      times[i][1] = g_get_monotonic_time ();

      check_fds (sockets, fds, NUM_POLLEES);

      for (j = 0; j < NUM_POLLEES / 2; j++)

        v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0;

      found_app = FALSE;

      while (!found_app && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))

        if (msg.message == WM_APP && msg.wParam == 1 && msg.lParam == 2)

          found_app = TRUE;

      g_assert (s == NUM_POLLEES / 2);

      g_assert (r == NUM_POLLEES / 2 + 1);

      g_assert (v == NUM_POLLEES / 2);

      g_assert (found_app);

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      r = g_poll (fds, NUM_POLLFDS, 0);

      check_fds (sockets, fds, NUM_POLLEES);

      g_assert (r == 0);

      diff = times[i][1] - times[i][0];

      if (times_min > diff)

        times_min = diff;

      if (times_max < diff)

        times_max = diff;

      times_avg += diff;

      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);

    }

  times_avg /= NUM_POLLEES;

  g_print ("half-socket + msg poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);

  print_buckets (buckets, bucket_limits, BUCKET_COUNT);

  times_avg = 0;

  times_min = G_MAXINT64;

  times_max = 0;

  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);

  for (i = 0; i < REPEAT; i++)

    {

      gint r, s, v, t;

      gint64 diff;

      gint j;

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      s = v = 0;

      for (j = 0; j < NUM_POLLEES; j++)

        s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0;

      g_usleep (G_USEC_PER_SEC / 1000);

      times[i][0] = g_get_monotonic_time ();

      r = g_poll (fds, NUM_POLLFDS, 1000);

      times[i][1] = g_get_monotonic_time ();

      check_fds (sockets, fds, NUM_POLLEES);

      for (j = 0; j < NUM_POLLEES; j++)

        v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0;

      g_assert (s == NUM_POLLEES);

      g_assert (r == NUM_POLLEES);

      g_assert (v == NUM_POLLEES);

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      r = g_poll (fds, NUM_POLLFDS, 0);

      check_fds (sockets, fds, NUM_POLLEES);

      g_assert (r == 0);

      diff = times[i][1] - times[i][0];

      if (times_min > diff)

        times_min = diff;

      if (times_max < diff)

        times_max = diff;

      times_avg += diff;

      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);

    }

  times_avg /= NUM_POLLEES;

  g_print ("%d-socket poll time: \n%4lldns - %4lldns, average %4lldns\n", NUM_POLLEES, times_min, times_max, times_avg);

  print_buckets (buckets, bucket_limits, BUCKET_COUNT);

  activatable = 0;

  times_avg = 0;

  times_min = G_MAXINT64;

  times_max = 0;

  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);

  for (i = 0; i < REPEAT; i++)

    {

      gint r, s, v, t;

      gint64 diff;

      gint j;

      MSG msg;

      gboolean found_app;

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      s = v = 0;

      for (j = 0; j < activatable; j++)

        s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0;

      g_assert (PostMessage (NULL, WM_APP, 1, 2));

      g_usleep (G_USEC_PER_SEC / 1000);

      times[i][0] = g_get_monotonic_time ();

      r = g_poll (fds, NUM_POLLFDS, 1000);

      times[i][1] = g_get_monotonic_time ();

      check_fds (sockets, fds, NUM_POLLEES);

      for (j = 0; j < activatable; j++)

        v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0;

      found_app = FALSE;

      while (!found_app && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))

        if (msg.message == WM_APP && msg.wParam == 1 && msg.lParam == 2)

          found_app = TRUE;

      g_assert (s == activatable);

      g_assert (r == activatable + 1);

      g_assert (v == activatable);

      g_assert (found_app);

      reset_fds (fds, NUM_POLLEES);

      reset_fds_msg (fds, NUM_POLLFDS);

      r = g_poll (fds, NUM_POLLFDS, 0);

      check_fds (sockets, fds, NUM_POLLEES);

      g_assert (r == 0);

      diff = times[i][1] - times[i][0];

      if (times_min > diff)

        times_min = diff;

      if (times_max < diff)

        times_max = diff;

      times_avg += diff;

      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);

      activatable = (activatable + 1) % NUM_POLLEES;

    }

  times_avg /= NUM_POLLEES;

  g_print ("variable socket number + msg poll time: \n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);

  print_buckets (buckets, bucket_limits, BUCKET_COUNT);

  cleanup_sockets (sockets, opp_sockets, NUM_POLLEES);

}

int

main (int   argc,

      char *argv[])

{

  int result;

  GMainContext *ctx;

  g_test_init (&argc, &argv, NULL);

  init_networking ();

  ctx = g_main_context_new ();

  g_test_add_func ("/gpoll/gpoll", test_gpoll);

  result = g_test_run ();

  g_main_context_unref (ctx);

  return result;

}