Python Server Page Performance Analysis and Modeling

The amount of dynamic Web contents and secured e‐commerce transactions has been dramatically increasing on the Internet, where proxy servers between clients and Web servers are commonly used for the purpose of sharing commonly accessed data and reducing Internet traffic. A significant and unnecessary Web access delay is caused by the overhead in proxy servers to process two types of accesses, namely dynamic Web contents and secured transactions, not only increasing response time, but also raising some security concerns. Conducting experiments on Squid proxy 2.3STABLE4, we have quantified the unnecessary processing overhead to show its significant impact on increased client access response times. We have also analyzed the technical difficulties in eliminating or reducing the processing overhead and the security loopholes based on the existing proxy structure. In order to address these performance and security concerns, we propose a simple but effective technique from the client side that adds a detector interfacing with a browser. With this detector, a standard browser, such as the Netscape/Mozilla, will have simple detective and scheduling functions, called a detective browser. Upon an Internet request from a user, the detective browser can immediately determine whether the requested content is dynamic or secured. If so, the browser will bypass the proxy and forward the request directly to the Web server; otherwise, the request will be processed through the proxy. We implemented a detective browser prototype in Mozilla version 0.9.7, and tested its functionality and effectiveness. Since we have simply moved the necessary detective functions from a proxy server to a browser, the detective browser introduces little overhead to Internet accessing, and our software can be patched to existing browsers easily. Copyright © 2004 John Wiley & Sons, Ltd.

The absence of benchmarks for Web sites with dynamic content has been a major impediment to research in this area. We describe three benchmarks for evaluating the performance of Web sites with dynamic content. The benchmarks model three common types of dynamic content Web sites with widely varying application characteristics: an online bookstore, an auction site, and a bulletin board. For the online bookstore, we use the TPCW specification. For the auction site and the bulletin board, we provide our own specification, modeled after ebay.com and slahdot.org, respectively. For each benchmark we describe the design of the database and the interactions provided by the Web server. We have implemented these three benchmarks with a variety of methods for building dynamic-content applications, including PHP, Java servlets and EJB (Enterprise Java Beans). In all cases, we use commonly used open-source software. We also provide a client emulator that allows a dynamic content Web server to be driven with various workloads. Our implementations are available freely from our Web site for other researchers to use. These benchmarks can be used for research in dynamic Web and application server design. In this paper, we provide one example of such possible use, namely discovering the bottlenecks for applications in a particular server configuration. Other possible uses include studies of clustering and caching for dynamic content, comparison of different application implementation methods, and studying the effect of different workload characteristics on the performance of servers. With these benchmarks we hope to provide a common reference point for studies in these areas.

There has been considerable increase in application layer attacks. Research surveys show that the cross site scripting (XSS) attack is most common among all the application layer attacks. Ajax Web technology, by design makes number of calls to the Web server to process a user request. This increases the bandwidth usage and response time due increase in the number of calls to the Web server. If security mechanisms are implemented to protect the application, then the server performance will suffer due to the additional processing required thereby resulting in increased response time. If security mechanisms are implemented to protect the application, then the server performance will suffer due to the increased response time because of the increase in number of requests. This problem demands an efficient approach to protect the Web application from XSS attacks and to block the malicious attempts from reaching the Web application. This paper presents a thread based solution for efficient process utilization of the Web server and to prevent XSS threats. The proposed solution has been tested using Java/JSP on JBOSS server on around 2000 vulnerable XSS input collected from various research sites, white hat and black hat sites. The model is also tested with the combination of non vulnerable input and vulnerable input to assess the performance. The approach is found to be effective compared to the earlier research works.

We present an architecture and prototype implementation of a performance management system for cluster-based web services. The system supports multiple classes of web services traffic and allocates server resources dynamically so to maximize the expected value of a given cluster utility function in the face of fluctuating loads. The cluster utility is a function of the performance delivered to the various classes, and this leads to differentiated service. In this paper we will use the average response time as the performance metric. The management system is transparent: it requires no changes in the client code, the server code, or the network interface between them. The system performs three performance management tasks: resource allocation, load balancing, and server overload protection. We use two nested levels of management mechanism. The inner level centers on queuing and scheduling of request messages. The outer level is a feedback control loop that periodically adjusts the scheduling weights and server allocations of the inner level. The feedback controller is based on an approximate first-principles model of the system, with parameters derived from continuous monitoring. We focus on SOAP-based web services. We report experimental results that show the dynamic behavior of the system.

In scheduling algorithms based on the Rate Monotonic (RM) method which are widely used in development of real-time systems, tasks with shorter periods have higher priorities. In contrast, ones with longer periods are likely to suffer from increased response times and jitter due to their lower priorities. We propose an Execution Right Delegation (ERD) method based on RM where a high-priority server for particular (or important) task is introduced to shorten response time and jitter of the task. In the evaluation, it is confirmed that response times and jitter of a particular (important) task are reduced. We also show Response Time Analysis (RTA), which assures worst-case response time of the task. This paper shows the algorithm and RTA of ERD and evaluates it by comparing it to a Deadline Monotonic method. The evaluation by simulation shows that ERD can reduce the average worst-case response time by 13.45% at maximum compared to the Deadline Monotonic scheduling. In addition, we confirm that the RTA provides a worst-case response time close to the simulation results.

We propose a new method for improving the average response time of Web servers by cooperatively caching the results of requests for dynamic content. The work is motivated by our recent study of access logs from the Alexandria Digital Library server at UCSB, which demonstrates that approximately a 30 percent decrease in average response time could be achieved by caching dynamically generated content. We have developed a distributed Web server called Swala, in which the nodes cooperatively cache the results of CGI requests, and the cache meta-data is stored in a replicated global cache directory. Our experiments show that the single-node performance of Swala without caching is comparable to the Netscape Enterprise server, that considerable speedups are obtained using caching, and that the cache hit ratio is substantially higher with cooperative cache than with stand-alone cache.

Bare PC applications do not use an operating system or kernel. The bare PC architecture avoids buffer copying, minimizes interrupts, uses a single thread of execution for processing network packets, and incorporates novel scheduling to minimize CPU utilization. We design a bare PC Web server that can serve both dynamic and static content. Measurements of response time, connection time and throughput for workloads containing requests for dynamic and static content indicate that the server has better performance than the Apache and IIS Web servers. For example, the bare PC server has a maximum request rate that is twice that of the Apache and IIS servers when serving dynamic content for small dataset sizes. Furthermore, at capacity the CPU utilization of the bare PC server is 1/5 <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">th</sup> that of the other servers. The bare PC server can also sustain a higher maximum request rate for dynamic pages with a given request rate for static pages. The studies demonstrate that the performance of the bare PC server when serving dynamic content is limited only by the latency of the database server.

Statistical modeling of emergency medical services’ response and rescue times to road traffic crashes in the Kingdom of Saudi Arabia

The need for the internet affects the growth in the number of website visitors and increases the server's traffic load. The increasing number of visitors often causes the website to overload due to an excessive number of requests despite the website still using a single server. So, it is necessary to apply Load Balancing techniques. The implementation requires an algorithm, specifically the Load Balancing method, which is responsible for dividing traffic as a workload among multiple servers. This research utilizes the Weighted Round Robin (WRR) algorithm, which considers server load based on device specifications. The scenario tests optimal performance load sharing among the WRR 1:1:1, WRR 2:1:1, and WRR 3:1:1 configurations then measures Response time and CPU Utilization. Testing is performed 30 times in each test scenario, and then the average value is taken. Giving traffic loads of 1000, 2000, and 3000 Requests using H2load Benchmark. The results of the WRR 2:1:1 ratio show that it is the most optimal, as the Load is evenly distributed among the three web servers. Reading the average CPU usage for 1000-3000 Request traffic, it reaches 71%-79% on Server 1, 47%-56% on Server 2, and 48%-56% on Server 3. Then, the average Response time is 223.77ms at 1000 Requests, 233.13ms at 2000 Requests, and 235.37ms at 3000 Requests.

Web services are increasingly used to enable interoperability and flexible integration of e-business systems. In this paper we focus on measurement-based performance analysis of an e-commerce application which uses Web services components to execute business operations. In our experiments we use a session-oriented workload generated by a tool developed accordingly to the TPC-W specification. The empirical results are obtained for two different user profiles, Browsing and Ordering, under different workload intensities. Unlike the previous work which was focused on the overall server response time and throughput, we present Web interaction, software architecture, and hardware resource level analysis of the system performance. In particular, we propose a method for extracting component level response times from the application server logs and study the impact of Web services and other components on the server performance. The results show that the response times of Web services components increase significantly under higher workload intensities when compared to other components. From the hardware resource measurements it is obvious that the higher response times of Web services components are due to parsing XML messages and contention for database resources. The results of our study identify software components and hardware resources which are potential bottlenecks in the system and thus provide valuable information for capacity planning of e-commerce applications

The monitoring system can automatically collect the quantitative data of the feeding behavior and feed intake of individual cattle, and the immediate response system always records many non-eating visits. Increasing response time of trigger helps to decrease recording non-eating visits, but may also miss some small periods of recording feed intake. This study was to evaluate the effect of response time in monitoring system on the accuracy of recording individual feeding behavior and feed intake in dairy cows. The first experiment was to investigate the distribution of 10-h feeding behaviors of 8 Holstein dairy cows after morning feeding by using infra-red camera. The second experiment was to investigate accuracy of feed intake recorded by the monitoring system with different response times (0.3, 3, 6, 12 and 24 s) in comparison with direct weighting. The third experiment was to investigate effect of excluding the data of time interval after response time on feed intake and visiting behaviors recorded by the monitoring system, when response time was set as 0.3 s. The results showed that the most of eating and non-eating visits had duration larger than 24 s (99.0 %) and less than 24 s (65.3 %), respectively. Comparing with actual feed intake obtained by direct weighting, increasing response time greatly increased the recorded feed intake, with the greatest difference occurring at 6 s of response time (P = 0.001). Although increasing time interval after response time linearly increased mean, median feed intake per visit and 10-h feed intake (P < 0.01), it had little influence on 10-h feed intake (< 0.1 %) and eating visit (< 5%). In summary, setting 0.3 s of response time in monitoring system helps to get actual feed intake, but can obtain a lot of non-eating visits. Increasing response time helps to decrease the recording of non-eating visits, but can overestimate feed intake.

Performance is one of the most important business requirements for web based applications. The suitability of better platform for any web based application depends on various factors attributable to processor architecture, memory, local/ global network, input/output characteristics etc. Performance testing is an important part of any distributed or web application testing plan. Inclusion of performance estimates into planning and development cycles ensures that the application delivered to the user satisfies sustained performance even at high load, availability and scalability requirements. In this paper we have thrown light on performance comparison of web applications on single and multi core servers. The tests have been carried out on single processor single core server and also on dual processor quad core Xeon based server. The performance comparison was carried out based on response time, throughput (No. of hits v/s response time) and connection pooling v/s no connection pooling. It was found that performance of Java applications running on the multi-core servers is far better than those running on single core servers. Web applications on quad-core server give better performance, high availability and scalability. Apache JMeter was used to load test the functional behaviour and measure performance based on throughput (No of hits v/s response time) for dynamic querying of data using Java servlets on Tomcat web server. Based on the analysis of performance of web server under varying load of no. of users and threads, it was found that applications on quad core server give more throughput and less response time as compared to single core server. Connection pooling increases the performance of web applications by reusing active database connections instead of creating a new connection with every request. Performance was compared by running the tests using Java servlets for connection pooling and also by acquiring connections directly from the JDBC driver without connection pooling. Based on the test results it was found that in case of quad core server, throughput i.e the number of requests served per second is much higher and reuse of connections from pool of connections showed significant improvement in application performance. This paper describes the results of tests carried out for comparing performance (based on response time) between web applications running on single core server and on quad core server. Tests have also been carried out to analyze advantage of connection pooling over no connection pooling. The test results have been shown graphically.

Web server load balancing: A queueing analysis

The use of process data, such as response time (RT) in psychometrics, has generally focused on the relationship between speed and accuracy. The potential relationships between RT and item discrimination remain less explored. In this study, we propose a model for simultaneously estimating the relationships between RT and item discrimination at the person, item, and person-by-item (residual) levels and illustrate our approach through an item-level meta-analysis of 40 empirical data sets comprising 1.84 million item responses. We find no evidence of average differences in item discrimination between items of different time intensity or persons of different average RT, while residual RT strongly and negatively predicts item discrimination (pooled coef. = -.27% per 1% difference in RT, SE = .04, = .17). While heterogeneity is high, we find little evidence of moderation by overall data set characteristics. Flexible generalized additive models show that the relationship between residual RT and item discrimination is generally curvilinear, with discrimination maximized just below average RT and minimized at the extremes. Our results suggest that RT data can provide insights into the measurement properties of educational and psychological assessments, but that the relationships between RT and item discrimination are highly variable.

In the face of massive concurrent user access in the era of big data, how to build high-performance web services has become one of the difficulties to be solved by network applications. This paper utilizes Node.js architecture to fully utilize the event-based programming and non-blocking I/O characteristics of JavaScript language to improve the CPU utilization of the web service side. It also proposes the strategy of predicting user-accessed resources for cache replacement through a Gaussian mixture model to further optimize the performance of high-concurrency web services. The performance of the high concurrency web framework constructed using Node.js technology plays excellent, the performance of multi-threaded Node.js is better than single-threaded, and compared with Apache architecture, the average response time, request-response rate, and data throughput test of Node.js architecture in high concurrency scenarios is more advantageous than Apache architecture. The Gaussian mixture clustering model is effective in dealing with data with high-dimensional features, and the average accuracy of the four clustering processes of each algorithm is, in descending order, GMM (79.67%), BIRCH (78.09%), and K-means (77.52%). In addition, the cache replacement strategy based on Gaussian Mixture Model is more effective, with an accuracy rate of nearly 80% and a byte hit rate of nearly 45% when the cache capacity reaches 214KB, which are both higher than the traditional cache replacement strategy with the same cache capacity.