Officially the topic is “Radio Resource Management for Quality of Service in Heterogeneous Wireless Networks”. This is quite the mouthful, I know. Really what it boils down to is: Making various wireless technologies (Bluetooth, WiFi, WiMAX, 3G, 4G, … , etc) seamlessly work together. Many devices are capable of connecting to many of these radio access technologies (RATs), but often it is not seamless. What do I mean by this? Well suppose I am inside a university building, deep in the basement (where they tend to put CS students ) where there is no mobile reception (3G, 4G etc.). I start downloading a large file, or call someone via wifi. Now I want to walk to my car because it’s time to go home for the day. Many networks now are not able to handle this, and it is interrupted after you change networks. Furthermore, you often have to manually tell the device you want to leave one network and join another. Seamless means this should all happen without you noticing. This is the focus of my research.

The biggest problem that I am concerned with is called handoff or handover. This is when the switch between RATs occurs. Traditionally, this also occurs when a mobile device switches from one tower to another, and it usually involved predicting the motion of the device along with some other factors for Quality of Service (QoS). For a vertical handover, we may or may not need to predict motion. If the heterogeneous wireless network (HWN) is densely covered, many RATs are available throughout the coverage region (as opposed to a sparsely covered where a given location may have access to one technology at once). In a dense HWN, the problem becomes a multi-criteria question.

1. Which network is most economical for me to connect to?
2. Which configuration of (network, client) pairs is most profitable for the operator?
3. Which network is able to provide me with the required QoS?

More technical details to follow…

Single connection server
This server is a basic echo server. A client connects to it on a specific port and enters strings on the stdin. The server maintains the connection until the client terminates the connection with a blank line.

The major weakness of this server is that it can only handle a single connection at once. So if the first connection is very slow, any subsequent connections must wait, even if they are ready to be handled. In the case of this server, the first user to connect may be very slow to type their strings, and even if the second user has already entered a string, it will not be displayed until the first user connection in completed.

Single connection server

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <netdb.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERROR(x) do { perror(x); exit(1); } while(0)

#define NAME       257
#define BUFSIZE    257
#define MAXPENDING 1

int main(int argc, char *argv[])
{
  unsigned short port;    /* Port to which server will bind */
  char servhost[NAME];    /* Local host name */
  struct sockaddr_in sock;  /* INTERNET socket space */
  struct hostent *server;    /* Local host information */
  int S;            /* fd for socket */
  int NS;            /* fd for connected socket */
  char buf[BUFSIZE];      /* Input buffer */
  FILE *fp;          /* Stream (converted file des.) */

  if (argc != 2)
  {
    fprintf(stderr,"usage: server <port>\n");
    exit(1);
  }

  port = atoi(argv[1]);

  /*
   * Get socket - INTERNET DOMAIN - TCP
   */
  if ((S = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    ERROR("server: socket");

  /*
   * Obtain host name & network address
   */
  gethostname(servhost, sizeof(servhost));
  if ((server = gethostbyname(servhost)) == NULL)
  {
    fprintf(stderr,"%s: unknown host\n",servhost);
    exit(1);
  }

  /*
   * Bind to server address - in network byte order
   */
  sock.sin_family = AF_INET;
  sock.sin_port = htons(port);
  memcpy(&sock.sin_addr, server->h_addr, server->h_length);

  /*
   * Bind socket to port/addr
   */
  if (bind(S, (struct sockaddr *)&sock, sizeof(sock)) < 0)
    ERROR("server: bind");

  /*
   * Listen on this socket
   */
  if (listen(S,MAXPENDING) < 0)
    ERROR("server: listen");
  
  
  //loop to continue handling connections
  while(1)
  {
    /*
     * Accept connections.  Once connected, the client will be
     * connected on fd NS, a second and third parameter may be passed
     * to accept which will be filled in with information regarding the
     * client connection if desired.
     *
     * In this example, once connected the server is done with the
     * master socket (so closes it).
     */
    if ((NS = accept(S,NULL,NULL)) < 0)
      ERROR("server: accept");

    /*
     * Using stdio library to read from socket
     */
    if (!(fp = fdopen(NS,"r")))
    {
      fprintf(stderr,">>> Error converting file des. to stream <<<\n");
      exit(1);
    }

    while (fgets(buf,BUFSIZE,fp))
      printf("%s", buf);

    /*
     * DONE - simply close() connection
     */
    fclose(fp);
    close(NS);
  }
  
  return(0);
}

fork() – Multiple connection, multiple process
In this case, the server can now handle multiple connections successfully. If the first connection has a long processing time or the user is slow at entering data, the second connection may now continue freely without waiting in line. The downside to this approach is: 1) If the server must handle a large number of connections simultaneously, the server may run out of processes since each connection fork()s. 2) Since a fork() call duplicates variables, file descriptors etc., the server may run out of memory if each connection requires any significant processing.

Notice that the processing portion of the code has been moved into a function which is called when the fork() is executing within the child processes.

Fork Server

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <netdb.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERROR(x) do { perror(x); exit(1); } while(0)

#define NAME       257
#define BUFSIZE    257
#define MAXPENDING 1

void handle_connection(int NS);

int main(int argc, char *argv[])
{
  unsigned short port;    /* Port to which server will bind */
  char servhost[NAME];    /* Local host name */
  struct sockaddr_in sock;  /* INTERNET socket space */
  struct hostent *server;    /* Local host information */
  int S;            /* fd for socket */
  int NS;            /* fd for connected socket */
  int pid;          /* used to determine parent or child */

  if (argc != 2)
  {
    fprintf(stderr,"usage: fork-server <port>\n");
    exit(1);
  }

  port = atoi(argv[1]);

  /*
   * Get socket - INTERNET DOMAIN - TCP
   */
  if ((S = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    ERROR("fork-server: socket");

  /*
   * Obtain host name & network address
   */
  gethostname(servhost, sizeof(servhost));
  if ((server = gethostbyname(servhost)) == NULL)
  {
    fprintf(stderr,"%s: unknown host\n",servhost);
    exit(1);
  }

  /*
   * Bind to server address - in network byte order
   */
  sock.sin_family = AF_INET;
  sock.sin_port = htons(port);
  memcpy(&sock.sin_addr, server->h_addr, server->h_length);

  /*
   * Bind socket to port/addr
   */
  if (bind(S, (struct sockaddr *)&sock, sizeof(sock)) < 0)
    ERROR("server: bind");

  /*
   * Listen on this socket
   */
  if (listen(S,MAXPENDING) < 0)
    ERROR("server: listen");
  
  while(1)
  {
    /*
     * Accept connections.  Once connected, the client will be
     * connected on fd NS, a second and third parameter may be passed
     * to accept which will be filled in with information regarding the
     * client connection if desired.
     *
     * In this example, once connected the server is done with the
     * master socket (so closes it).
     */
    if ((NS = accept(S,NULL,NULL)) < 0)
      ERROR("server: accept");
      
    if((pid = fork()) < 0)
      ERROR("server: fork");
    if(pid == 0)
    {
      handle_connection(NS);
      exit(0);
    }
    else
      close(NS);
  }

  return(0);
}

void handle_connection(int NS)
{
  char buf[BUFSIZE];      /* Input buffer */
  FILE *fp;          /* Stream (converted file des.) */
  
  /*
   * Using stdio library to read from socket
   */
  if (!(fp = fdopen(NS,"r")))
  {
    fprintf(stderr,">>> Error converting file des. to stream <<<\n");
    exit(1);
  }

  while (fgets(buf,BUFSIZE,fp))
    printf("%s", buf);

  /*
   * DONE - simply close() connection
   */
  fclose(fp);
  close(NS);
}

select() – Multiple connection, single process
The last case still has the benefits of fork() but does so in a single process. In this case, select() is used. In this case, each socket descriptor is monitored by select which determines if any of the sockets are ready for I/O. Rather than sitting idly waiting for input on sockets that are not ready, data is processed as it arrives. The drawback to this approach is that it is little trickier to implement and understand, but if you start with a basic case like this it can be quite simple to get the hang of it. When using select(), we need to specify the groups of sockets we wish to monitor. This is done using the fd_set which you can see in the source.

Select Server

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <netdb.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERROR(x) do { perror(x); exit(1); } while(0)

#define NAME       257
#define BUFSIZE    257
#define MAXPENDING 1

void handle_connection(int NS, fd_set * activefds);

int main(int argc, char *argv[])
{
  fd_set readfds, activefds;  /* the set of read descriptors */
  unsigned short port;    /* Port to which server will bind */
  char servhost[NAME];    /* Local host name */
  struct sockaddr_in sock;  /* INTERNET socket space */
  struct hostent *server;    /* Local host information */
  int S;            /* fd for socket */
  int NS;            /* fd for connected socket */
  int i;            /* counter to go through FDs in fdset */

  if (argc != 2)
  {
    fprintf(stderr,"usage: select-server <port>\n");
    exit(1);
  }

  port = atoi(argv[1]);

  /*
   * Get socket - INTERNET DOMAIN - TCP
   */
  if ((S = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    ERROR("select-server: socket");

  /*
   * Obtain host name & network address
   */
  gethostname(servhost, sizeof(servhost));
  if ((server = gethostbyname(servhost)) == NULL)
  {
    fprintf(stderr,"%s: unknown host\n",servhost);
    exit(1);
  }

  /*
   * Bind to server address - in network byte order
   */
  sock.sin_family = AF_INET;
  sock.sin_port = htons(port);
  memcpy(&sock.sin_addr, server->h_addr, server->h_length);

  /*
   * Bind socket to port/addr
   */
  if (bind(S, (struct sockaddr *)&sock, sizeof(sock)) < 0)
    ERROR("server: bind");

  /*
   * Listen on this socket
   */
  if (listen(S,MAXPENDING) < 0)
    ERROR("server: listen");
  
  /* Initialize the set of active sockets. */
    FD_ZERO (&activefds);
    FD_SET (S, &activefds);
  
  while(1)
  {
    /* Block until input arrives on one or more active sockets. */
        readfds = activefds;
        if (select (FD_SETSIZE, &readfds, NULL, NULL, NULL) < 0)
        {
      perror ("select");
            exit (EXIT_FAILURE);
        }
    
    /* Service all the sockets with input pending. */
    for (i = 0; i < FD_SETSIZE; ++i)
    {
      if (FD_ISSET (i, &readfds))
      {
        if (i == S)
        {
          /* Connection request on original socket. */

          /*
           * Accept connections.  Once connected, the client will be
           * connected on fd NS, a second and third parameter may be passed
           * to accept which will be filled in with information regarding the
           * client connection if desired.
           *
           * In this example, once connected the server is done with the
           * master socket (so closes it).
           */
          if ((NS = accept(S,NULL,NULL)) < 0)
            ERROR("server: accept");
          FD_SET(NS, &activefds);  //add the new socket desc to our active connections set
        }
        else
        {
          /* Data arriving on an already-connected socket. */
          handle_connection(i, &activefds);
        }
      }
    } /* //end of for */
  } /* //end of while */

  return(0);
}

void handle_connection(int NS, fd_set * activefds)
{
  char buf[BUFSIZE];      /* Input buffer */
  FILE *fp;          /* Stream (converted file des.) */
    
  /*
   * Using stdio library to read from socket
   */
  if (!(fp = fdopen(NS,"r")))
  {
    fprintf(stderr,">>> Error converting file des. to stream <<<\n");
    exit(1);
  }

  //if fgets fails we have end of line, quit
  if(!(fgets(buf,BUFSIZE,fp)))
  {
    /*
     * DONE - simply close() connection
     */
    fclose(fp);
    close(NS);
    FD_CLR(NS, activefds);
  }
  else
    printf("%s", buf);
}

Additional Information
http://www.uoguelph.ca/~jernst/3110/cis3310-lab4.pdf
http://www.socs.uoguelph.ca/~dbm/teaching/CIS3110/
http://beej.us/guide/bgnet/
manpages!

I have submitted the final draft of an adaptive scheduling algorithm for wireless networks to BWCCA conference in Japan. I intend to present my findings in November.

The ACM Group I am chair of is organizing a computer programming contest at Guelph for the fall semester. We are also planning to try to field a team for ACM ICPC* Update * We have been featured in the ACM student publication crossroads: http://tinyurl.com/25u5vxt.

A few days ago I found out I am the teaching assistant for CIS2030 at Guelph for the second time! I am excited to be back, and expect to do a good job since I am becoming familiar with the course.

Lastly, my thesis has been progressing slowly this semester. I am still in the stage where I am deciding where to focus my work. The general area I am exploring is heterogeneous wireless networks, however there are many problems and it is difficult to choose one to focus on. Since I worked in scheduling for my MSc. thesis, I intend to move in a bit different of a direction so that I expand my knowledge. (although I still may publish some more scheduling papers since I still have some ideas in that area)

While I don’t have a video for you to watch the entire presentation, I do have some pictures, and I’ll post the paper and slides I presented in case any one is interested. If you have any questions feel free to post on here or email me directly and I’ll be happy to answer any of them.

J.B. Ernst and M.K. Denko, “Cross-Layer Mixed Bias Scheduling for Wireless Mesh Networks,” in Proc. IEEE International Conference on Communications (ICC), Cape Town, South Africa, 2010.

Abstract—In this paper we propose a mixed bias approach which makes use of cross layer optimization. The cross-layer parameters are based on conditions in the network from multiple layers and are used to determine resource and time allocation for nodes in the network. Unlike existing proposals, we propose to bias against several parameters such as link quality and queue size in addition to node distance. We also propose a combined mixed bias approach which takes into account multiple parameters together. The scheme is evaluated using simulation experiments. The performance results are reported in this paper.

Download the paper (pdf)
Download the presentation slides (pdf)

There were people from 40 different countries there and I feel like I met someone from almost every one of them at some point. There were over 300 people at AINA this year, which apparently is down from the last couple of years (where they had 4-500) but it was still a great conference for me. I will post my slides from my presentation in this post in case anyone is interested, along with a link to the paper once it is available. I submitted another paper last night for a conference in Toronto and am working on two more papers, so hopefully I’ll be travelling soon. I am trying to aim for ICC in South Africa next year.

Here are a few pictures from the conference.

Abstract:
This paper addresses the problem of scheduling in Wireless Mesh Networks (WMNs). The paper first discusses existing scheduling algorithms and classifies them based on the technique they use and their implementation frameworks.Then detailed discussions of the proposed scheduling method are presented. Simulation experiments are conducted to compare the performance of fair scheduling with the method that does not use fair scheduling. The simulation results confirm that the proposed scheduling method has better performance with respect to the metrics used for performance evaluation.

J.B. Ernst, M.K. Denko, “Fair Scheduling with Multiple Gateways in Wireless Mesh Networks”, in Proc. of the 22nd IEEE Int. Conf. on Advanced Information Networking and Applications (AINA 2009), Bradford UK, 2009.

The paper itself is available through IEEE Xplore

Here are some pictures from the day:

Preparing for the Defense before Everyone Arrives

Some Members of Pervasive Computing and Wireless Network (PerWin) Research Group, University of Guelph

Answering Questions from the Committee at Guelph

After some relaxing, a conference in UK and some business related projects I will finally have some time (hopefully) to update the site with all the projects, articles and source I have been slowly working on the past few months in between working like crazy on my M.Sc. This fall I start my Ph.D. which will likely at least start from the work I just worked on.

The paper is on a greedy reduction algorithm that finds the minimum number of connections required for a set of routing requirements. I have probably mentioned something about it in earlier posts. The algorithm has quite a few applications. My advisor, Dr. Fan plans to use it for designing circuits, networks-on-chip and FPGAs and I have used it in a simulation for wireless networks. I will post the paper sometime after I get the go-ahead from my advisor, which I imagine will be sometime after it has been officially published.

I realize this post is somewhat sort and theres not much to it but theres not much time for posting these days since the advisors are pushing me to decide on a new direction for my thesis within the next couple of days. So back to work for me, yay reading!

An example Interconnection Graph Problem, Click to Enlarge

Since December of 2007 I have been working at implementing, testing and experimenting the algorithm as well as providing feedback and new ideas for improvements. The paper is almost ready to be submitted for publication this so hopefully I will be able to provide a link to it in the future.

In relation with my thesis, I am planning on making use of the CRIN algorithm to attempt to optimize wireless network protocols. There still needs to be some experimentation and research to determine if in fact the algorithm can be used in this way however I feel optimistic that this is the case.

There is also the potential that the source code for the CRIN implementation may be made open source and released for use by anyone. If this is the case it will be uploaded to this site in the future.