Capriccio: scalable threads for internet services Export

@inproceedings{citeulike:208329, abstract = {This paper presents Capriccio, a scalable thread package for use with high-concurrency servers. While recent work has advocated event-based systems, we believe that threadbased systems can provide a simpler programming model that achieves equivalent or superior performance. By implementing Capriccio as a user-level thread package, we have decoupled the thread package implementation from the underlying operating system. As a result, we can take advantage of cooperative threading, new asynchronous I/O mechanisms, and compiler support. Using this approach, we are able to provide three key features: (1) scalability to 100,000 threads, (2) efficient stack management, and (3) resource-aware scheduling. We introduce linked stack management, which minimizes the amount of wasted stack space by providing safe, small, and non-contiguous stacks that can grow or shrink at run time. A compiler analysis makes our stack implementation efficient and sound. We also present resource-aware scheduling, which allows thread scheduling and admission control to adapt to the system's current resource usage. This technique uses a blocking graph that is automatically derived from the application to describe the flow of control between blocking points in a cooperative thread package. We have applied our techniques to the Apache 2.0.44 web server, demonstrating that we can achieve high performance and scalability despite using a simple threaded programming model.}, address = {New York, NY, USA}, author = {von Behren, Rob and Condit, Jeremy and Zhou, Feng and Necula, George C. and Brewer, Eric}, booktitle = {Proceedings of the 19th Symposium on Operating System Principles (SOSP '03)}, citeulike-article-id = {208329}, citeulike-linkout-0 = {http://portal.acm.org/citation.cfm?id=945471}, citeulike-linkout-1 = {http://dx.doi.org/10.1145/945445.945471}, citeulike-linkout-2 = {http://www.cs.berkeley.edu/%7Ebrewer/papers/capriccio-sosp-2003.pdf}, comment = {Nice work on building a highly-scalable threading mechanism. However, it's fairly intrusive in the software stack (e.g., requires a glib overlay and even gcc changes). Are these intrusions worth-while? My view is that things have changed: years ago, when servers would start choking on as few as 50 threads, events looked good as a general approach to server scalability. Today, however, servers can easily handle 1,000 threads. This covers the needs of most servers. Only a very few kinds of servers (typically variants on proxy servers) need to handle 10K connections. For these, events make sense. For most servers, threads on the standard OS thread package makes sense. In neither case do we need a special threading package. See also http://www.citeulike.org/user/rstata/article/2190494 for higher-level discussion of events vs. threads.}, doi = {10.1145/945445.945471}, isbn = {1581137575}, journal = {ACM SIGOPS Operating Systems Review}, keywords = {cluster-computing, has-note, scalable-threading}, pages = {268--281}, posted-at = {2008-01-03 19:28:34}, priority = {0}, publisher = {ACM Press}, title = {Capriccio: scalable threads for internet services}, url = {http://dx.doi.org/10.1145/945445.945471}, year = {2003} }

TY - CONF ID - citeulike:208329 L3 - citeulike-article-id:208329 N2 - This paper presents Capriccio, a scalable thread package for use with high-concurrency servers. While recent work has advocated event-based systems, we believe that threadbased systems can provide a simpler programming model that achieves equivalent or superior performance. By implementing Capriccio as a user-level thread package, we have decoupled the thread package implementation from the underlying operating system. As a result, we can take advantage of cooperative threading, new asynchronous I/O mechanisms, and compiler support. Using this approach, we are able to provide three key features: (1) scalability to 100,000 threads, (2) efficient stack management, and (3) resource-aware scheduling. We introduce linked stack management, which minimizes the amount of wasted stack space by providing safe, small, and non-contiguous stacks that can grow or shrink at run time. A compiler analysis makes our stack implementation efficient and sound. We also present resource-aware scheduling, which allows thread scheduling and admission control to adapt to the system’s current resource usage. This technique uses a blocking graph that is automatically derived from the application to describe the flow of control between blocking points in a cooperative thread package. We have applied our techniques to the Apache 2.0.44 web server, demonstrating that we can achieve high performance and scalability despite using a simple threaded programming model. JF - ACM SIGOPS Operating Systems Review SN - 1581137575 AD - New York, NY, USA EP - 281 TI - Capriccio: scalable threads for internet services PB - ACM Press T2 - Proceedings of the 19th Symposium on Operating System Principles (SOSP '03) SP - 268 KW - cluster-computing KW - has-note KW - scalable-threading N1 - Nice work on building a highly-scalable threading mechanism. However, it's fairly intrusive in the software stack (e.g., requires a glib overlay and even gcc changes). Are these intrusions worth-while? My view is that things have changed: years ago, when servers would start choking on as few as 50 threads, events looked good as a general approach to server scalability. Today, however, servers can easily handle 1,000 threads. This covers the needs of most servers. Only a very few kinds of servers (typically variants on proxy servers) need to handle 10K connections. For these, events make sense. For most servers, threads on the standard OS thread package makes sense. In neither case do we need a special threading package. See also http://www.citeulike.org/user/rstata/article/2190494 for higher-level discussion of events vs. threads. AU - von Behren, Rob AU - Condit, Jeremy AU - Zhou, Feng AU - Necula, George AU - Brewer, Eric PY - 2003/// UR - http://dx.doi.org/10.1145/945445.945471 ER -