The portable common runtime approach to interoperability

WeiserM.,; DemersA.,; HauserC.,

doi:10.1145/74851.74862

Cited by 36 publications

(10 citation statements)

References 14 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…34 A user would register a specific callback routine with the general garbage collector, for use on a specific type of objects. So when the garbage collector recognises one of these objects during traversal, it applies the appropriate callback to collect the object.…”

Section: Applicabilitymentioning

confidence: 99%

See 1 more Smart Citation

A customisable memory management framework for C++

Attardi

Flagella

Iglio

1998

Softw: Pract. Exper.

View full text Add to dashboard Cite

SUMMARYAutomatic garbage collection relieves programmers from the burden of managing memory themselves and several techniques have been developed that make garbage collection feasible in many situations, including real time applications or within traditional programming languages. However, optimal performance cannot always be achieved by a uniform general purpose solution. Sometimes an algorithm exhibits a predictable pattern of memory usage that could be better handled specifically, delaying as much as possible the intervention of the general purpose collector. This leads to the requirement for algorithm specific customisation of the collector strategies. We present a dynamic memory management framework which can be customised to the needs of an algorithm, while preserving the convenience of automatic collection in the normal case. The Customisable Memory Manager (CMM) organises memory in multiple heaps. Each heap is an instance of C؉؉ class which abstracts and encapsulates a particular storage discipline. The default heap for collectable objects uses the technique of mostly copying garbage collection, providing good performance and memory compaction. Customisation of the collector is achieved exploiting object orientation by defining specialised versions of the collector methods for each heap class. The object-oriented interface to the collector enables coexistence and coordination among the various collectors as well as integration with traditional code unaware of garbage collection. The CMM is implemented in C؉؉ without any special support in the language or the compiler. The techniques used in the CMM are general enough to be applicable also to other languages. The performance of the CMM is analysed and compared to other conservative collectors for C/C؉؉ in various configurations.

show abstract

Section: Applicabilitymentioning

confidence: 99%

“…In the Portable Common Runtime, 34 when an upcall is registered with the collector, a type code is returned that can be used to tag objects at their creation. This is used to support different programming languages, which have different allocation primitives.…”

Section: Applicabilitymentioning

confidence: 99%

A customisable memory management framework for C++

Attardi

Flagella

Iglio

1998

Softw: Pract. Exper.

View full text Add to dashboard Cite

show abstract

“…In this way, virtually all sequential C programs of the SACLIB library, on which ReDuX is built, will execute unmodified as a single S-thread, with a slight execution penalty imposed by the parallel list-processing context. S-threads runs on the Mach and Solaris 2.x kernel threads, but also on the user-level threads provided by PCR (Weiser et al, 1989), which in turn runs on UNIX System V.…”

Section: Parallel Symbolic Computation With Virtual S-threadsmentioning

confidence: 99%

Parallel Term Rewriting with Paredux

Bündgen¹,

Göbel²,

Küchlin³

et al. 1998

Applied Logic Series

View full text Add to dashboard Cite

“…The resulting difference in context switch time is often substantial. Weiser, Demers, and Hauser [27] report a context switch time of 77 µs for user-level threads in the Portable Common Runtime on a SPARC-based workstation. The context switch time for the thread package used in the Psyche experiments is 51 µs.…”

Section: Comparison To Kernel-implemented Processesmentioning

confidence: 99%

“…To overcome these problems, it has become commonplace to construct lightweight thread packages in user space [4,9,23,27]. These packages multiplex a potentially large number of user-defined threads on top of a single kernel-implemented process.…”

Section: Introductionmentioning

confidence: 99%

First-class user-level threads

Marsh

Scott

LeBlanc

et al. 1991

Proceedings of the Thirteenth ACM Symposium on Operating Systems Principles

106

View full text Add to dashboard Cite

It is often desirable, for reasons of clarity, portability, and efficiency, to write parallel programs in which the number of processes is independent of the number of available processors. Several modern operating systems support more than one process in an address space, but the overhead of creating and synchronizing kernel processes can be high. Many runtime environments implement lightweight processes (threads) in user space, but this approach usually results in second-class status for threads, making it difficult or impossible to perform scheduling operations at appropriate times (e.g. when the current thread blocks in the kernel). In addition, a lack of common assumptions may also make it difficult for parallel programs or library routines that use dissimilar thread packages to communicate with each other, or to synchronize access to shared data.We describe a set of kernel mechanisms and conventions designed to accord first-class status to user-level threads, allowing them to be used in any reasonable way that traditional kernel-provided processes can be used, while leaving the details of their implementation to userlevel code. The key features of our approach are (1) shared memory for asynchronous communication between the kernel and the user, (2) software interrupts for events that might require action on the part of a user-level scheduler, and (3) a scheduler interface convention that facilitates interactions in user space between dissimilar kinds of threads. We have incorporated these mechanisms in the Psyche parallel operating system, and have used them to implement several different kinds of user-level threads. We argue for our approach in terms of both flexibility and performance.

show abstract

The portable common runtime approach to interoperability

Cited by 36 publications

References 14 publications

A customisable memory management framework for C++

A customisable memory management framework for C++

Parallel Term Rewriting with Paredux

First-class user-level threads

Contact Info

Product

Resources

About