/* 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;
}