Abstract
Building distributed applications is difficult mostly because of concurrency management. Existing approaches primarily include events and threads. Researchers and developers have been debating for decades to prove which is superior. Although the conclusion is far from obvious, this long debate clearly shows that neither of them is perfect. One of the problems is that they are both complex and error-prone. Both events and threads need the programmers to explicitly manage concurrencies, and we believe it is just the source of difficulties. In this paper, we propose a novel approach—superscalar communication, in which concurrencies are automatically managed by the runtime system. It dynamically analyzes the programs to discover potential concurrency opportunities; and it dynamically schedules the communication and the computation tasks, resulting in automatic concurrent execution. This approach is inspired by the idea of superscalar technology in modern microprocessors, which dynamically exploits instruction-level parallelism. However, hardware superscalar algorithms do not fit software in many aspects, thus we have to design a new scheme completely from scratch. Superscalar communication is a runtime extension with no modification to the language, compiler or byte code, so it is good at backward compatibility. Superscalar communication is likely to begin a brand new research area in systems software, which is characterized by dynamic optimization for networking programs.
This is a preview of subscription content, log in via an institution to check access.
Similar content being viewed by others
References
Lu X, Wang H, Wang J. Internet-based virtual computing environment (iVCE): Concepts and architecture. Sci China Ser F-Inf Sci, 2006, 49: 681–701
Li D, Lu X. A novel constant degree and constant congestion DHT scheme for peer-to-peer networks. Sci China Ser F-Inf Sci, 2005, 48: 421–436
Zhang Y M, Lu X C, Li D S. SKY: Efficient peer-to-peer networks based on distributed Kautz graphs. Sci China Ser F-Inf Sci, 2009, 52: 588–601
Lauer H C, Needham R M. On the duality of operating system structures. SIGOPS Oper Syst Rev, 1979, 13: 3–19
Adya A, Howell J, Theimer M, et al. Cooperative task management without manual stack management. In: ATEC’02: Proceedings of the General Track of the Annual Conference on USENIX Annual Technical Conference. Berkeley, CA, USA, 2002. 289–302
von Behren R, Condit J, Brewer E. Why events are a bad idea (for high-concurrency servers). In: HOTOS’03: Proceedings of the 9th Conference on Hot Topics in Operating Systems, Berkeley, CA, USA, 2003. 4–4
Ousterhout J K. Why threads are a bad idea (for most purposes). In: Presentation given at the 1996 Usenix Annual Technical Conference. Berkely: USENIX Association, 1996
Halstead R H Jr. Multilisp: a language for concurrent symbolic computation. ACM Trans Program Lang Syst, 1985, 7: 501–538
Krohn M, Kohler E, Kaashoek M F. Events can make sense. In: ATEC’07: Proceedings of the General Track of the Annual Conference on USENIX Annual Technical Conference. Berkely: USENIX Association, 2007
Fielding R T. Architectural styles and the design of network-based software architectures. PhD thesis, Chair-Taylor, Richard N. 2000
von Behren R, Condit J, Zhou F, et al. Capriccio: scalable threads for internet services. In: SOSP’ 03: Proceedings of the Nineteenth ACM Symposium on Operating Systems Principles. New York: ACM, 2003. 268–281
Mohr E, Kranz D A, Halstead R H Jr. Lazy task creation: a technique for increasing the granularity of parallel programs. In: LFP’90: Proceedings of the 1990 ACM Conference on LISP and Functional Programming. New York: ACM, 1990. 185–197
Killian C E, Anderson J W, Braud R, et al. Mace: language support for building distributed systems. In: PLDI’07: Proceedings of the 2007 ACM SIGPLAN Conference on Programming Language Design and Implementation. New York: ACM, 2007. 179–188
Cunningham R, Kohler E. Making events less slippery with eel. In: HOTOS’05: Proceedings of the 10th Conference on Hot Topics in Operating Systems. Berkeley: USENIX Association. 2005. 3–3
Chandrasekaran P, Conway C L, Joy J M, et al. Programming asynchronous layers with clarity. In: ESEC-FSE’ 07: Proceedings of the 6th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering. New York: ACM, 2007. 65–74
Welsh M, Culler D, Brewer E. Seda: an architecture for well-conditioned, scalable internet services. SIGOPS Oper Syst Rev, 2001, 35: 230–243
Dabek F, Zeldovich N, Kaashoek F, et al. Event-driven programming for robust software. In: EW10: Proceedings of the 10th Workshop on ACM SIGOPS European Workshop. New York: ACM, 2002. 186–189
Schmidt D C, Huston S D. C++ Network Programming: Systematic Reuse with ACE and Frameworks. Boston: Addison-Wesley Professional, 2003
Li P, Zdancewic S. Combining events and threads for scalable network services implementation and evaluation of monadic, application-level concurrency primitives. SIGPLAN Not, 2007, 42: 189–199
Fischer J, Majumdar R, Millstein T. Tasks: language support for event-driven programming. In: PEPM’07: Proceedings of the 2007 ACM SIGPLAN Symposium on Partial Evaluation and Semantics-based Program Manipulation. New York: ACM, 2007. 134–143
Nightingale E B, Veeraraghavan K, Chen P M, et al. Rethink the sync. In: OSDI’ 06: Proceedings of the 7th USENIX Symposium on Operating Systems Design and Implementation. Berkeley: USENIX Association, 2006. 1–1
Author information
Authors and Affiliations
Corresponding author
Rights and permissions
About this article
Cite this article
Li, H., Liu, S., Peng, Y. et al. Superscalar communication: A runtime optimization for distributed applications. Sci. China Inf. Sci. 53, 1931–1946 (2010). https://doi.org/10.1007/s11432-010-4051-4
Received:
Accepted:
Published:
Issue Date:
DOI: https://doi.org/10.1007/s11432-010-4051-4