1. Department of Computer Science & Engineering Green Client/Server Software to Save Energy in Network Devices Axel Vigo, Mentor: Miguel Jimeno, Advisor: Dr. Ken Christensen Background Many client/server applications (such as telnet and IM) maintain a TCP connection at all times. If the client enters a sleep state, the connection is broken and the server will “clean-up” its resources and lose data. That is, application state is tied to connection state. In this existing paradigm, clients cannot use existing power management capabilities and thus energy is wasted when the client is idle. Office and network equipment consume about $6 billion in electricity per year in the US. But we could save up to 32% if power management were enabled (K. Kawamoto et al., “Electricity Used by Office and Network Equipment in the U.S.”, Lawrence Berkeley National Lab, 2001). Solution One possible solution is to allow the server to buffer data for a disconnected and sleeping client. When the client wakes up and reconnects to the server, the buffered data is delivered to the client as illustrated in figure 1. Thus, the server does not clean-up resources when a client temporarily disconnects. REU 2007 Problem The problem is how to decouple application state from TCP connection state. Is it possible for a server application to allow a client to enter a sleep state during periods of inactivity and sustain application state in the server? If this can be done, a client could enable power management and consume less energy without losing important data. Evaluation The client and server programs were implemented in C using Windows sockets, semaphores, and threads. The sever program follows the design shown in figure 2 and sends a string to the client every minute which represents data traffic. When the client goes to “sleep”, the server stores the data in a queue. Once the client wakes up, the buffered messages are sent as shown in figure 3. Program gServer() wait for connection request from client establish connection start reconnect() start send() do forever if (buffer is not full) generate data and write to queue Process reconnect() do forever wait for client to disconnect wait for connection request from client establish connection to client Process send() do forever wait for queue to contain data if (disconnected from client) wait for connection to be established dequeue all data from queue and send Figure 1: How the green server and client work Figure 2: Server program pseudocode Figure 3: Server and client programs running Summary & Future Work In this project a new model for client/server applications to allow client computers to enter a sleep state and save energy was explored. The feasibility of server buffering during periods of disconnect was demonstrated via a prototype application. Future work includes: 1. Designing a method for the server to wake up the client when the server buffers are full. 2. Implementing this method in an actual application, such as in the telnet server in Linux.