waashk/acm huggingface dataset:
increasing tlb reach using superpages backed by shadow memory the amount of memory that can be accessed without causing a tlb fault, the reach of a tlb, is failing to keep pace with the increasingly large working sets of applications. we propose to extend tlb reach via a novel memory controller tlb (mtlb) that lets us aggressively create superpages from non-contiguous, unaligned regions of physical memory. this flexibility increases the os's ability to use superpages on arbitrary application data. the mtlb supports shadow pages, regions of physical address space for which the mtlb remaps accesses to "real" physical pages. the mtlb preserves per-base-page referenced and dirty bits, which enables the os to swap shadow-backed superpages a page at a time, unlike conventional superpages. simulation of five applications, including two specint95 benchmarks, demonstrated that a modest-sized mtlb improves performance of applications with moderate-to-high tlb miss rates by 5-20%. simulation also showed that this mechanism can more than double the effective reach of a processor tlb with no modification to the processor mmu. mark swanson leigh stoller john carter
evolving toward ada in real time systems  the ada view of multitasking represents a radical departure from the traditional "cyclic executive" approach to real time operating systems. since system designers must by necessity be conservative, it would be unrealistic to expect an abrupt change of this magnitude in engineering practice. instead, this paper outlines a sequence of intermediate steps designed so that the advantages and familiar structures of cyclic systems may be retained, while the capabilities of ada multitasking are gradually incorporated. a scale of increasing scheduling complexity provides the justification for this sequence. the discussion of each step then briefly mentions some of the related benefits and costs. the paper draws some conclusions about the use of ada in real time systems.  lee maclaren
the ml approach to the readable all-purpose language  the ideal computer language is seen as one that would be as readable as natural language, and so adaptable that it could serve as the only language a user need ever know. an approach to language design has emerged that shows promise of allowing one to come much closer to that ideal than might reasonably have been expected. using this approach, a language referred to as ml has been developed, and has been implemented as a language-creation system in which user-defined procedures invoked at translation time translate the source to some object code. in this way the user can define both the syntax and the semantics of the source language. both language and implementation are capable of further development. this paper describes the approach, the language, and the implementation and recommends areas for further work.  c. r. spooner
on relative completeness of programming logics  in this paper a generalization of a certain lipton's theorem (see lipton [5]) is presented. namely, we show that for a wide class of programming languages the following holds: the set of all partial correctness assertions true in an expressive interpretation i is uniformly decidable (in i) in the theory of i iff the halting problem is decidable for finite interpretations. in the effect we show that such limitations as effectiveness or herbrand definability of interpretation (they are relevant in the previous proofs) can be removed in the case of partial correctness.  michal grabowski
a variable-arity procedural interface  this paper presents a procedural interface that handles optional arguments and indefinite numbers of arguments in a convenient and efficient manner without resorting to storing the arguments in a language-dependent data structure. this interface solves many of the problems inherent in the use of lists to store indefinite numbers of arguments. simple recursion can be used to consume such arguments without the complexity problems caused by the use of the lisp procedure apply on argument lists. an extension that supports multiple return values is also presented.  r. kent dybvig robert hieb
high level description and implementation of resource schedulers  resource sharing problems can be described in three basically independent components.  • the constraints the resource places upon sharing because of physical limitations and consistency requirements.  • the desired ordering of resource requests to achieve efficiency---either efficiency of resource utilization or efficiency for processes making the requests.  • modifications to the ordering, to prevent starvation of processes waiting for requests which might otherwise never receive service.  a high level description language to specify these components of resource sharing problems is introduced. an implementation that lends itself to mechanical synthesis is described. synthesis of the scheduler code by-passes the long and error- prone process of someone doing the coding themselves. proof techniques at the high level description level are introduced to show how to prove schedulers, synthesized from their description, are or are not deadlock and starvation free. solutions to the classical resource sharing problems of producer/consumer, reader/ writer, and disk scheduler (to the sector level) are shown to illustrate the expressiveness of this description language.  dennis w. leinbaugh
optimizing ada on the fly one of the features that makes ada such a reliable programming language is its use of run-time constraint checks. however, such checks slow program execution and increase program size.the adamagic compiler uses one-pass, on-the-fly flow analysis during intermediate-language generation specifically to eliminate unnecessary constraint checks and to warn about potential error situations such as the use of uninitialized variables.the one-pass nature of our method allows for faster compile times than more elaborate multi-pass flow analysis. thus, we are able to generate efficient code without the impact on compile-time, and without the added implementation complexity, associated with a traditional separate optimization phase. sheri j. bernstein robert s. duff
translation of nested apl to c++: problems and approaches  this paper discusses the task of developing a nested apl compiler and puts forward the project of such a compiler. the proposed approach consists of simulating the semantics of apl by using the object-oriented c++ programming language. different kinds of problems ranging from apl syntax ambiguity to the implementation of nested arrays and the robustness of compiled code are considered and different solutions are proposed. we conclude that it is feasible to develop a robust nested apl compiler, although the problem of performance demands further research.  dmitri gusev igor pospelov
design and implementation of a parallel pipe the parallel pipe par_pipe is a communication mechanism. data which are written to the par_pipe by a single process can be read by multiple processes concurrently in first-in-first-out manner, where all reading processes read the entire data stream. we use a dynamic partitioned buffer limited in size only by available hardware resources to ensure that the writing process cannot be blocked because of slow reading processes. in a further step we examine how far caching with an optimized saving policy on top of the file based buffer can improve the performance of the par_pipe. design and implementation of two versions of the par_pipe (one without caching, one with caching) are described. we outline the general advantages of the par_pipe over conventional unix shell script solutions and evaluate the results of performance measurements done for both par_pipe versions. jonathan karges otto ritter sándor suhai
aspectj: the language and support tools  complex systems usually contain design units that are logically related to several objects in the system. some examples include: tracing, propagation of interrupts, multi- object protocols, security enforcement etc. this crosscutting between those design units and the objects is a natural phenomenon. but, using traditional implementation techniques, the source code --- i.e. the classes --- becomes tangled with the implementation of the crosscutting concerns.  aspectj is an aspect-oriented extension to the java programming language that enables the clean modularization of crosscutting concerns. using aspectj we can encapsulate in program modules (aspects) the implementation of those design units that would otherwise be spread across the classes.  this demo illustrates what the aspectj language can do and it shows the tools that support developing programs with this language. we present an example program, and demonstrate the edit-compile-debug cycle in an ide that supports aspectj.  erik hilsdale jim hugunin mik kersten gregor kiczales cristina lopes jeffrey palm
perspectives on programming environments  many people have realized that programming needs more support than a compiler, linker, debugger, and a few other tools. more comprehensive systems have been proposed, built, and (sometimes) used. although the perfect programming environment is yet to be found, people have widely divergent views of the ideal. this paper neither surveys the field nor describes any single environment, but instead offers some attributes by which programming environments can be classified. it frequently uses the unix system to illustrate these attributes, and comments on the implications of the unix system's success for other programming environments.  john r. mashey
the common lisp object system metaobject kernel: a status report  the metaobject kernel of the common lisp object system (clos) comprises the classes and methods that define and implement the behavior of the system. since clos is an object-oriented program itself, exposing this kernel allows people to make useful integrated extensions to clos without changing the behavior of the system for ordinary programs, and without unwarranted loss of efficiency. this paper is organized around the classes used to implement clos, describing reasons for the class organization chosen, and how these classes participate in some protocols of the system.  daniel g. bobrow gregor kiczales
the role of fourth generation tools in systems development (abstract only)  recently many fourth generation tools have become available for commercial use. many companies are using these new tools which automate portions of the application development process. companies are experimenting with new approaches to systems development. information centers and prototyping are two of the new approaches which incorporate fourth generation tools. the potential impact of fourth generation tools on the training of systems analysts will be discussed. attempts to organize material about these tools for effective presentation will be described.  carol chrisman barbara beccue
toward a comprehensive, knowledge-based software design course  many colleges and universities teach courses in the design and implementation of so-called expert systems. such a course might include discussions of topics from traditional (symbolic) artificial intelligence, and culminate in the construction of a prototypical rule-based system. in general, the emphasis is on the use of knowledge compiled and encoded by the designer. here, an alternative approach is suggested in which such a course is broadened to include fundamental topics from the study of artificial neural nets. in this way the student is exposed to the notion that not only can program knowledge be contributed directly by the designers, but might also be extracted by the software from the data itself.  david thomas carl steidley
ada applications on embedded targets  the ada language system/navy (als/n) is a retarget of the ada language system (als) to navy standard 32 bit and 16 bit target computers (an/uyk-43, an/uyk-44, and an/ayk-14). we have developed a run time model which allows large ada applications to be fielded and run on limited address space machines. the run time model can be naturally extended to describe a fully distributed execution environment.  michael r. middlemas
using partial order techniques to improve performance of data flow analysis based verification partial order optimization techniques for distributed systems improve the performance of finite state verification approaches by avoiding redundant exploration of some portions of the state space. previously, such techniques have been applied in the context of model checking approaches. in this paper we propose a partial order optimization of the program model used by flavers, a data flow based finite state verification approach for checking user-specified properties of distributed software. we demonstrate experimentally that this optimization often leads to significant reductions in the run time of the analysis algorithm of flavers. on average, for those cases where this optimization could be applied, we observed a speedup of 21%. for one of the cases, the optimization resulted in an analysis speedup of 91%. gleb naumovich lori a. clarke jamieson m. cobleigh
design of the s system for data analysis  s is a language and system for interactive data analysis and graphics. it emphasizes interactive analysis and graphics, ease of use, flexibility, and extensibility. while sharing many characteristics with other statistical systems, s differs significantly in its design goals, its implementation, and the way it is used. this paper presents some of the design concepts and implementation techniques in s and relates these general ideas in computing to the specific design goals for s and to other statistical systems.  richard a. becker john m. chambers
formal specification and design of a message router  formal derivation refers to a family of design techniques that entail the development of programs which are guaranteed to be correct by construction. only limited industrial use of such techniques (e.g., unity-style specification refinement) has been reported in the literature, and there is a great need for methodological developments aimed at facilitating their application to complex problems. this article examines the formal specification and design of a message router in an attempt to identify those methodological elements that are likely to contribute to successful industrial uses of program derivation. although the message router cannot be characterized as being industrial grade, it is a sophisticated problem that poses significant specification and design challenges---its apparent simplicity is rather deceiving. the main body of the article consists of a complete formal specification of the router and a series of successive refinements that eventually lead to an immediate construction of a correct unity program. each refinement is accompanied by its design rationale and is explained in a manner accessible to a broad audience. we use this example to make the case that program derivation provides a good basis for introducing rigor in the design strategy, regardless of the degrees of formality one is willing to consider.  christian creveuil gruia- catalin roman
a program integration algorithm that accommodates semantics-preserving transformations  given a program base and two variants, a and b, each created by modifying separate copies of base, the goal of program integration is to determine whether the modifications interfere, and if they do not, to create an integrated program that includes both sets of changes as well as the portions of base preserved in both variants. text-based integration techniques, such as the one used by the unix diff3 utility, are obviously unsatisfactory because one has no guarantees about how the execution behavior of the integrated program relates to the behaviors of base, a, and b. the first program- integration algorithm to provide such guarantees was developed by horwitz et al.[13]. however, a limitation of that algorithm is that it incorporates no notion of semantics- preserving transformations. this limitation causes the algorithm to be overly conservative in its definition of interference. for example, if one variant changes the way a computation is performed (without changing the values computed) while the other variant adds code that uses the result of the computation, the algorithm would classify those changes as interfering. this paper describes a new integration algorithm that is able to accommodate semantics-preserving transformations.  wuu yang susan horwitz thomas reps
the recursive application of the object-oriented design methodology (abstract only)  the object-oriented design (ood) methodology has generated much interest in the ada* community as a way of exploiting the features of ada to achieve the goals of software engineering. when used in the design of a large system, it must be recursively applied at successive levels of abstraction. there has been, however, little actual experience with this. the author has applied ood recursively to the design of a large system. the major issues involved in this will be presented, including package creation, type decomposition, operation absorption, and bottom-up use of resources.  mark temte
engineering a simple, efficient code-generator generator  many code- generator generators use tree pattern matching and dynamic programming. this paper describes a simple program that generates matchers that are fast, compact, and easy to understand. it is simpler than common alternatives: 200-- 700 lines of icon or 950 lines of c versus 3000 lines of c for twig and 5000 for burg. its matchers run up to 25 times faster than twig's. they are necessarily slower than burg's burs (bottom-up rewrite system) matchers, but they are more flexible and still practical.  christopher w. fraser david r. hanson todd a. proebsting
compiler construction using attribute grammars  the adequacy of attribute grammars as a compiler writing tool is studied on the basis of the experiences on attribute grammars for pascal and a subset of euclid. a qualitative assessment of the grammars shows that the compiler oriented view in the design of an attribute grammar tends to make the grammar hard to understand. a design discipline is proposed to improve the comprehensibility of the grammar. quantitative measurements of the automatically generated compilers suggest that an efficient compiler can be produced from an attribute grammar. to achieve this, a carefully optimized implementation of the compiler-compiler is required.  kai koskimies kari-jouko räihä matti sarjakoski
ansi basic - the proposed standard  the proposed standard for the programming language basic, although not yet approved, is sufficiently stable to permit examination and discussion. it contains, for example the usual structural constructs, multicharacter variable names, external subroutines, two-dimensional plotting, and several simple file types. optional extensions include additional file types, real-time, and a fixed-decimal module for business applications.  the panel will present the main features of the proposed standard, will briefly discuss these features, and will accept questions about the standard. (two of the panelists are members of ansi committee x3j2, charged with developing the standard.)  ronald e. anderson
designing in the dark: logics that compete with the user  skills developed by software user interface designers to solve problems in communication, management, implementation, and other areas may influence design decisions in the absence of sufficient knowledge of user populations. given today's rapid change in both "faces" to the software interface --- user populations and software functionality --- the first pass at a design may be made without sufficient understanding of the relevant goals and behaviors of the eventual users. without this information, designers are less able to grasp "user logic", and may rely on more familiar "logics" that are useful in other problem-solving arenas. understanding how these approaches can affect a design may help us recognize them across a wide range of contexts and enable us to focus the human factors contribution to the design evolution process.  j. grudin
resource abstract data type + synchronization - a methodology for message oriented programming -  we present in this paper a methodology for the development (and analysis) of programs designed specifically for distributed environments where synchronization is achieved through message passing. the methodology is based on techniques and concepts which have been found to be useful for the development of sequential programs---namely, stepwise refinement and abstract data types. the methodology is based on the concept of resource, generalizing the concepts of monitors, managers, proprietors, etc. we put forward the proposition that a resource is an abstract data type together with mechanisms for synchronization: firstly, for the operations of the type with each other (to gain parallelism) and, secondly, to enable the user environment to perform operation invocation. a methodology is then presented for the design of resources and their implementation.  p. r.f. cunha t. s.e. maibaum
a performance comparison between an apl interpreter and compiler  an analysis of the execution of several simple apl statements illustrates that interpretive overhead in the form of setup time is awesome, and is on the order of 100 times as much as the per-element time. comparison with an experimental compiler for apl illustrates that the setup time can often be eliminated or reduced greatly, producing code fragments that are more than 300 times as fast in favorable cases. further work on the compiler should make some compiled code fragments about 500 times as fast as interpreted programs in favorable cases. in less favorable cases, performance improvements of a factor of two are commonplace. many opportunities remain to improve the performance in such cases. a production compiler based on this work might allow use of apl to solve problems that in the past have been prohibitively expensive for apl solution.  clark wiedmann
technical correspondence  the column, "benchmarks for lan performance evaluation," by larry press (aug. 1988, pp. 1014-1017) presented a technique for quickly benchmarking the performance of lans in an office environment. this piqued our interest since office automation is growing in importance. as a result, an empirical analysis of the press benchmark programs was conducted. the results indicated that these benchmarking programs were appropriate for the benchmarking of lans in an office environment.  diane crawford
smart recompilation  with current compiler technology, changing a single line in a large software system may trigger massive recompilations. if the change occurs in a file with shared declarations, all compilation units depending upon that file must be recompiled to assure consistency. however, many of those recompilations may be redundant, because the change may affect only a small fraction of the overall system.  smart recompilation is a method for reducing the set of modules that must be recompiled after a change. the method determines whether recompilation is necessary by isolating the differences among program modules and analyzing the effect of changes. the method is applicable to languages with and without overloading. a prototype demonstrates that the method is efficient and can be added with modest effort to existing compilers.  walter f. tichy