Lightweight remote procedure call
ACM Transactions on Computer Systems (TOCS)
Project Oberon: the design of an operating system and compiler
Project Oberon: the design of an operating system and compiler
A concurrent, generational garbage collector for a multithreaded implementation of ML
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Portable, unobtrusive garbage collection for multiprocessor systems
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Extensibility safety and performance in the SPIN operating system
SOSP '95 Proceedings of the fifteenth ACM symposium on Operating systems principles
Concurrent programming in ERLANG (2nd ed.)
Concurrent programming in ERLANG (2nd ed.)
A generational on-the-fly garbage collector for Java
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
JESSICA: Java-enabled single-system-image computing architecture
Journal of Parallel and Distributed Computing - Special Issue on Java on Clusters
Implementing an on-the-fly garbage collector for Java
Proceedings of the 2nd international symposium on Memory management
J-Kernel: a capability-based operating system for Java
Secure Internet programming
Multitasking without comprimise: a virtual machine evolution
OOPSLA '01 Proceedings of the 16th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
ATEC '02 Proceedings of the General Track of the annual conference on USENIX Annual Technical Conference
A Language-Based Approach to Security
Informatics - 10 Years Back. 10 Years Ahead.
COMPCON '97 Proceedings of the 42nd IEEE International Computer Conference
cJVM: A Single System Image of a JVM on a Cluster
ICPP '99 Proceedings of the 1999 International Conference on Parallel Processing
Architectural styles and the design of network-based software architectures
Architectural styles and the design of network-based software architectures
Occam Programming Manual
Eliminating synchronization-related atomic operations with biased locking and bulk rebiasing
Proceedings of the 21st annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications
Language support for fast and reliable message-based communication in singularity OS
Proceedings of the 1st ACM SIGOPS/EuroSys European Conference on Computer Systems 2006
Singularity: rethinking the software stack
ACM SIGOPS Operating Systems Review - Systems work at Microsoft Research
Processes in KaffeOS: isolation, resource management, and sharing in java
OSDI'00 Proceedings of the 4th conference on Symposium on Operating System Design & Implementation - Volume 4
Foundations of the C++ concurrency memory model
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
XMem: type-safe, transparent, shared memory for cross-runtime communication and coordination
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
Virtual machines should be invisible
Proceedings of the compilation of the co-located workshops on DSM'11, TMC'11, AGERE!'11, AOOPES'11, NEAT'11, & VMIL'11
S-RVM: a secure design for a high-performance java virtual machine
Proceedings of the sixth ACM workshop on Virtual machines and intermediate languages
Analyzing memory ownership patterns in C libraries
Proceedings of the 2013 international symposium on memory management
Hi-index | 0.00 |
As software becomes increasingly complex and difficult to analyze, it is more and more common for developers to use high-level, type-safe, object-oriented (OO) programming languages and to architect systems that comprise multiple components. Different components are often implemented in different programming languages. In state-of-the-art multicomponent, multi-language systems, cross-component communication relies on remote procedure calls (RPC) and message passing. As components are increasingly co-located on the same physical machine to ensure high utilization of multi-core systems, there is a growing potential for using shared memory for cross-language cross-runtime communication. We present the design and implementation of Co-Located Runtime Sharing (CoLoRS), a system that enables cross-language, cross-runtime type-safe, transparent shared memory. CoLoRS provides object sharing for co-located OO runtimes for both static and dynamic languages. CoLoRS defines a language-neutral object/classmodel,which is a static-dynamic hybrid and enables class evolution while maintaining the space/time efficiency of a static model. CoLoRS uses type mapping and class versioning to transparently map shared types to private types. CoLoRS also contributes a synchronization mechanism and a parallel, concurrent, on-the-fly GC algorithm, both designed to facilitate cross-language cross-runtime object sharing. We implement CoLoRS in open-source, production-quality runtimes for Python and Java. Our empirical evaluation shows that CoLoRS extensions impose low overhead. We also investigate RPC over CoLoRS and find that using shared memory to implement co-located RPC significantly improves both communication throughput and latency by avoiding data structure serialization.