Online Feedback-based Estimation of Dynamic Page Service Time Ashwini Kumar, Kaushik Veeraraghavan, Benjamin Wester, Kang Shin EECS Department, University of Michigan {ashwinik, kaushikv, bwester, kgshin}@eecs.umich.edu Abstract—We present a framework for estimating the service time of a dynamic HTTP request by using the service times of past requests to the same URL. Our framework tags incoming requests with a timestamp. As the request is processed, server state relevant to the estimation mechanism, such as the number of threads servicing incoming requests, is stored with each request. When a request is handled, it is timestamped again, allowing us to calculate its service time. This service time is added to the history table and used in the computation of future estimates. The estimators we evaluated do not produce accurate predictions when server resources change, leaving room for further work in estimator design. I. I NTRODUCTION Unlike traditional web pages that can be cached on a web server or in the browser, only certain components (such as standardized text) of dynamic web pages can be served faster by caching or pre-fetching [4]. With the advent of adaptive advertisements, personalized online shopping and similar technologies, dynamic web pages that require extensive server-side processing are becoming increasingly prevalent. One concern when serving dynamic pages is determining the server resources required to provide end-users with good quality of service. A possible way to do this is to analyze incoming service requests and provide greater control over their processing to the web server. A precise estimate of a request’s service time would be useful for providing good quality of service. We propose a general feedback-based framework for estimating this service time. Our framework functions as follows. For each URL, the web server tracks the service time of recently-completed requests in a history table. Upon receipt of a new request, we use our history table to compute an estimate for the request. When this request completes, its measured service time updates the history table. We built our estimation framework, called Sirocco, atop the Staged Event Driven Architecture (SEDA) [13] infrastruc- ture for developing event-driven applications. Our estimation mechanism predicts request service times when the server is operating under regular (i.e., non-overloaded) conditions. To preserve the accuracy of our estimates under varying loads, we experiment with different estimate computation schemes. We analyze our results and describe a general set of properties that estimators should possess. The estimation framework is: 1) online: estimation is performed at runtime; 2) adaptive: our feedback mechanism tracks varying ser- vice times (perhaps due to changing service load); and 3) cheap: while increasing the number of tracked URLs is limited by server-side resources such as memory, this does not impact end-user request service times. Along with its use in web services, we envision the impact of our estimation techniques in other areas: 1) Load balancing: Oftentimes, large websites employ load-balancing schemes to distribute resources, and traf- fic, amongst multiple servers. Sirocco will provide a reasonably accurate service time for every URL, and help construct better load-balancing mechanisms. 2) Web server administration: An accurate service time estimation would enable the development of applications that can better manage web servers. For instance, a website that distinguishes between paid and unpaid users can monitor service times for paid users’ accesses and guarantee them better service. 3) Virtual host services: With the emergence of rentable enterprise-scale data centers [8], dynamic allocation of servers, applications and communication bandwidth is a novel problem. An efficient solution will require an excellent service and load estimation technique to correctly predict resource requirements. There are some limitations to our framework. To have a meaningful correlation between a URL’s history and its service time, the page at that URL must be generated in a constant processing time. We have not fully addressed the behavior of our history/estimation scheme under server overload scenarios. The rest of this paper describes our framework design, implementation and evaluation. We then describe future work. II. RELATED WORK Over the years, web servers have incorporated novel scheduling [2], traffic shaping [12], graceful degradation un- der overloaded scenarios [1], and other server performance improvements [13], [10]. To the best of our knowledge, there is no work that directly deals with the problem of estimating the service time of dynamic requests to a web server. III. DESIGN Figure 1 shows an overview of the framework. The central component of our framework is the history table. We chose to denote different dynamic applications as different URLs. For each dynamic URL, we maintain a history table entry