Generational garbage collection algorithms achieve efficiency because newer records point to older records; the only way an older record can point to a newer record is by a store operation to a previously-created record, and such operations are rare in many languages. A garbage collector that concentrates just on recently allocated records can take advantage of this fact. Such a garbage collector can be so efficient that the allocation of records costs more than their disposal. A scheme for quick record allocation attacks this bottleneck. Many garbage-collected environments don't know when to ask the operating system for more memory. A robust heuristic solves this problem. This paper presents a simple, efficient, low-overhead version of generational garbage collection with fast allocation, suitable for implementation in a Unix environment.

The runtime data structures of the Standard ML of New Jersey compiler are simple yet general. As a result, code generators are easy to implement, programs execute quickly, garbage collectors are easy to implement and work efficiently, and a variety of runtime facilities can be provided with ease.

Debuggers are specific to the machines, operating systems, and languages that they support. Much of a debugger has to be re-implemented for each new machine, so debuggers that work with a variety of machines and operating systems can get unwieldy. Improvements to debuggers may be lost unless they are re-implemented as users move to new machines. If retargeting debuggers were easier, other improvements would be more valuable. This thesis describes the design and implementation of ldb, a prototype retargetable debugger. Dealing with symbol-table formats is one of the most machine-dependent aspects of debuggers. ldb eliminates this machine dependence by using one format on all machines. The format is a language---a dialect of PostScript, which is extensible and can represent procedures. ldb reduces retargeting effort associated with variations in run-time support by controlling its target process using a debug nub, which is a small piece of object code linked with the target program. Mu...

What abstractions should a reusable code generator provide to make it easy for a language implementor to compile a highly concurrent language? The implementation of concurrency is typically tightly interwoven with the code generator and run-time system of the high-level language. Our contribution is to tease out the tricky low-level concurrency mechanisms and to package them in an elegant way, so they can be reused by many front ends. This paper has been submitted to PLDI'01. 1 Introduction C-- is a compiler-target language intended to be independent of both source programming language and target architecture (Peyton Jones, Oliva, and Nordin 1997; Peyton Jones, Ramsey, and Reig 1999; Ramsey and Peyton Jones 2000). It acts as an interface between a front end and a reusable code generator. The idea is that the front end translates your favorite language into C--, leaving the C-- compiler to do the rest. C-- encapsulates compilation techniques that are well understood, but dicult to im...

As computer systems are becoming increasingly complex, directing tools are gaining in importance. Directing denotes two classes of activities, monitoring and controlling. Monitoring is used for collecting information about the program behavior. Controlling is used to modify the program state in order to change program's future behavior. Some characteristic directing tools are debuggers and performance monitors. Dynascope is a directing platform, which provides basic monitoring and controlling primitives. These primitives are used in building advanced directing applications for networked and heterogeneous environments. Dynascope is integrated with existing programming tools and uses only generic operating system and networking primitives. This paper describes the design and implementation of the directing server, the central component of Dynascope. Dynascope is being used in several applications, including relative debugging, steering agents, and simulator testing. 1 Introduction Incre...

this paper, we describe a new architecture for thread and scheduling subsystems that provides correct, extensible and efficient thread management for applications. The strand architecture enables applications to place their specialized thread management code in the kernel address space. This allows the operating system to perform upcalls without crossing costly hardware boundaries. As well, it enables applications to contact other system services with low overhead. The system safety issues that arise when placing application code in the kernel are handled in two ways. First, application handlers are written in a typesafe language, Modula-3, to ensure memory-safety. A user thread package executing in the kernel cannot corrupt the kernel's memory or call inappropriate kernel procedures. Second, the strand interface is structured to prohibit the failure of any application handler from affecting threads not directly managed by that handler. The end result is that the strand architecture allows application code to be tightly integrated with system services, thereby enabling correct, safe and efficient implementations of specialized thread managers. We have implemented the strands architecture in the context of SPIN, which is an extensible operating system being developed at the University of Washington. Using strands, we have implemented several threads packages, including CThreads[Cooper

EZ is a system that integrates the facilities provided separately by traditional programming languages and operating systems. This integration is accomplished by casting services provided by traditional operating services as EZ language features. EZ is a high-level string processing language with a persistent memory. Traditional file and directory services are provided by EZ’s strings and associative tables, and tables are also used for procedure activations. This paper describes processes in EZ, which are procedure activations that execute concurrently and share the same, persistent virtual address space. They are semantically similar to ‘threads ’ or ‘lightweight processes ’ in some operating systems. Processes are values. They are just associative tables and have all of the characteristics of other EZ values, including persistence. Examples of their use and a brief overview of their implementation are included. 1.

We present a framework for preemptive threads in C--. We describe the front- and back-end runtime system support requirements of our model. Our model extends the current C-- framework with new services. In particular, we suggest two extensions to the back-end runtime interface: a mechanism for saving the state of a suspended execution and a revised mechanism for resuming the state of a suspended execution. We demonstrate the plausibility of our model for the simplest case and conjecture on its extensibility to the general case.

Abstract not found