waashk/acm huggingface dataset:
experiences using ada in a real-time and distributed laboratory this paper reviews our experience in the laboratory of two courses in the control engineering curriculum at the politechnical university of valencia: real-time systems and distributed control systems. these courses, in a control engineering curriculum, require the development of industrial prototypes to validate different aspects of the system development: control algorithms, real-time software design, external devices integration, distributed control, etc. to meet all these goals a robot guidance experience has been selected. in this paper, we describe the experience in the design and implementation of a virtual and real environment developed in ada to complete the student laboratory activities. the system is complex enough to allow the students to analyze, design and implement a complete prototype p. ballbastre s. terrasa j. vila a. crespo
virtual address translation for wide-address architectures operating systems employ virtual memory mechanism to provide large address space for programs. the efficiency of the virtual address translation plays an important role in determining system performance. in conventional virtual memory management systems, both the forward-mapped page table scheme and inverted page table scheme are widely used to organize the page tables that record translation data. these two schemes work well for 32-bit architectures, but not for wide address (64-bit) architectures. these two schemes either needs long translation time or incurs large memory overhead when translating wide virtual address. to cope with this problem, we propose a hybrid scheme to accelerate wide virtual address translation. ing-jye shyu shiuh-pyng shieh
towards a graphical notation to express the c++ template instantiation process (poster session)  c++ programmers who make intensive use of templates for developing applications get poor support from the compilers they use. typical error reporting associated with template analysis ranges from long, nested, and therefore complex expressions, to short but cryptic messages. this poster introduces a graphical notation that can be used as an intermediate abstract medium on which the result of template analysis can be expressed. the motivation of our approach is to make template analysis and error reporting two orthogonal activities. if compiler implementors adopt a standard notation to express the result of template analysis, tools to help programmers visualize/understand errors can be independently developed, and used as compiler "plug-ins", which will hopefully have a positive impact on issues such as programmer's productivity and product quality. we have used this notation to manually parse examples taken from the stl, and less known powerful uses of templates, such as expression templates, and template meta- programming. the preliminary stage we are reporting on has helped us to (a) identify elements that are needed in the notation, (b) identify limitations that are due to the instantiation model inherently associated with the language, and (d) have a sense of how useful the notation can be to pinpoint errors associated with the analysis of non-trivial cases such as expression templates.  arturo j. sanchez jia dei-wei
assignment and procedure call proof rules  the multiple assignment statement is defined in full generality---including assignment to subscripted variables and record fields---using the "axiomatic" approach of hoare. proof rules are developed for calls of procedures using global variables, var parameters, result parameters, and value parameters, using the idea of multiple assignment to provide understanding. an attempt is made to clarify some issues that have arisen concerning the use of rules of inference to aid in generating "verification conditions" in mechanical verifiers and the use of logical variables to denote initial values of program variables.  david gries gary levin
tichy's response to r. w. schwanke and g. e. kaiser's "smarter recompilation"  schwanke and kaiser's extension of smart recompilation is an intriguing idea. their mechanism aims at delaying recompilation work by permitting "harmless" compilation inconsistencies to remain after changes. full consistency can be reestablished at a later time, after the change has been tested in a subpart of the system. if the change was inadequate, then no needless compilation work was performed. this strategy is used frequently in practice, by exploiting loopholes in system generation tools. schwanke and kaiser's mechanism is novel in that it makes this practice safe. the compiler is aware of the inconsistencies, and will not overlook dangerous ones. furthermore, it can help reestablish full consistency once a change is deemed acceptable.  smarter recompilation defines a harmless inconsistency as follows. if a declaration is changed, this action is treated as introducing a new version of the declaration. the coexistence of both the old and new versions in the same configuration is a harmless inconsistency as long as the uses of the two versions do not conflict. the system must be separable into two partitions, one that uses the old version and the other the new one, such that the interface between the two depends on neither. since the inconsistent declarations do not cross the interface, the two partitions may even communicate with each other. of course, inconsistencies not captured by the type system cannot be treated in this way.  schwanke and kaiser's note leaves a few minor questions unanswered. for instance, a new or changed declaration might cause a redeclaration or overloading error that can only be detected by recompilation. is this potential problem left undetected until full consistency is desired, or is it checked immediately? if a declaration is deleted that is still in use, is the deletion treated as an error or as a delayed deletion that will take effect after the last use disappears? if the old and new versions of a procedure operate on the same data structure, is it always desirable to let both versions coexist, or can the programmer indicate that the old version should be eliminated before the next program execution? perhaps a future paper about an implementation will clarify these points.  smarter recompilation also opens the door for more powerful programming tools. for example, since the mechanism maintains cross-reference information, a tool like masterscope [1] could be built relatively easily. the tool would have the advantage that cross-reference information is immediately available once a module has been compiled. only little additional data would be needed to classify the uses of symbols. the information could also be exploited by a maintainer's assistant. this program helps with reestablishing consistency after changes by suggesting corrections of the affected program parts. for example, it could attempt to make call sites of changed procedures consistent with their headers, update operations on changed record fields, or perform some simple program transformations in response to data structure changes.  w. tichy
a status report on research in transparent informed prefetching this paper focuses on extending the power of caching and prefetching to reduce file read latencies by exploiting application level hints about future i/o accesses. we argue that systems that disclose high-level knowledge can transfer optimization information across module boundaries in a manner consistent with sound software engineering principles. such transparent informed prefetching (tip) systems provide a technique for converting the high throughput of new technologies such as disk arrays and log-structured file systems into low latency for applications. our preliminary experiments show that even without a high-throughput i/o subsystem tip yields reduced execution time of up to 30% for applications obtaining data from a remote file server and up to 13% for applications obtaining data from a single local disk. these experiments indicate that greater performance benefits will be available when tip is integrated with low level resource management policies and highly parallel i/o subsystems such as disk arrays. r. hugo patterson garth a. gibson m. satyanarayanan
dynamic optimistic interprocedural analysis: a framework and an application in this paper, we address the problem of _dynamic optimistic interprocedural analysis_. our goal is to build on past work on _static interprocedural analysis_ and _dynamic optimization_ by combining their advantages. we present a framework for performing dynamic optimistic interprocedural analysis. the framework is designed to be used in the context of dynamic class loading and dynamic compilation, and includes mechanisms for event notification (on class loading and method compilation) and dependence tracking (to enable invalidation of optimistic assumptions). we illustrate the functionality of the framework by using it to be used in the context of dynamic class loading and dynamic compilation, and includes mechanisms for event notification (on class loading and method compilaton) and dependence tracking (to enable invalidation of optimistic assumptions). we illustrate the functionality of the framework by using it to implement a _dynamic optimistic interprocedural type_ (doit) analysis algorithm. the doit algorithm uses a new global data structure called the _value graph_. the framework and doit analysis of the ibm jalapeño java virtual machine. our experimental results for the specjvm benchmarks and two larger programs show promising benefits due to dynamic optimistic analysis. compared to pessimistic analysis, the reduction in number of methods and fields analyzed was in the 2.7x-4.6x and 1.6-2.4x ranges respectively. the average fraction of polymorphic virtual calls decreased from 39.5% to 24.4% due to optimistic analysis, with a _best-case_ decrease from 47.0% to 8.1%. the average fraction of _polymorphic interface calls_ decreased from 96.4% to 36.2% due to optimistic analysis, with a _best- case_ decrease from 100.0% to 0.0%. these benefits were obtained with a low dynamic analysis overhead in the range of 570-930 bytecode bytes/millisecond (about 2.5x-5.4x faster than the jalapeño baseline compiler)
performance estimation for embedded systems with data and control dependencies  in this paper we present an approach to performance estimation for hard real- time systems. we consider architectures consisting of multiple processors. the scheduling policy is based on a preemptive strategy with static priorities. our model of the system captures both data and control dependencies, and the analysis is able to reduce the pessimism of the estimation by using the knowledge about these dependencies. extensive experiments as well as a real life example demonstrate the efficiency of our approach.  paul pop petru els zebo peng
software performance estimation strategies in a system-level design tool  high-level cost and performance estimation, coupled with a fast hardware/software co-simulation framework, is a key enabler to a fast embedded system design cycle. unfortunately, the problem of deriving such estimates without a detailed implementation available is difficult.  in this paper we describe two approaches to solve software cost and performance estimation problem, and how they are used in an embedded system design environment. a source-based approach uses compilation onto a virtual instruction set, and allows one to quickly obtain estimates without the need for a compiler for the target processor. an object-based approach translates the assembler generated by the target compiler to "assembler-level," functionally equivalent t c. in both cases the code is annotated with timing and other execution related information (e.g., estimated memory accesses) and is used as a precise, yet fast, software simulation model. we contrast the precision and speed of these two techniques comparing them with those obtainable by a state- of-the-art cycle-based processor model.  jwahar r. bammi wido kruijtzer luciano lavagno edwin harcourt mihai t. lazarescu
a simple and efficient implementation of a small database  this paper describes a technique for implementing the sort of small databases that frequently occur in the design of operating systems and distributed systems. we take advantage of the existence of very large virtual memories, and quite large real memories, to make the technique feasible. we maintain the database as a strongly typed data structure in virtual memory, record updates incrementally on disk in a log and occasionally make a checkpoint of the entire database. we recover from crashes by restoring the database from an old checkpoint then replaying the log. we use existing packages to convert between strongly typed data objects and their disk representations, and to communicate strongly typed data across the network (using remote procedure calls). our memory is managed entirely by a general purpose allocator and garbage collector. this scheme has been used to implement a name server for a distributed system. the resulting implementation has the desirable property of being simultaneously simple, efficient and reliable.  a. birrell m. jones e. wobber
class management for software communities  object-oriented programming may engender an approach to software development characterized by the large- scale reuse of object classes. large-scale reuse is the use of a class not just by its original developers, but by other developers who may be from other organizations, and may use the classes over a long period of time. our hypothesis is that the successful dissemination and reuse of classes requires a well-organized community of developers who are ready to share ideas, methods, tools and code. furthermore, these communities should be supported by software information systems which manage and provide access to class collections. in the following sections we motivate the need for software communities and software information systems. the bulk of this article discusses various issues associated with managing the very large class collections produced and used by these communities.  simon gibbs eduardo casais oscar nierstrasz x. pintado dennis tsichritzis
time warp operating system  this paper describes the time warp operating system, under development for three years at the jet propulsion laboratory for the caltech mark iii hypercube multi-processor. its primary goal is concurrent execution of large, irregular discrete event simulations at maximum speed. it also supports any other distributed applications that are synchronized by virtual time.  the time warp operating system includes a complete implementation of the time warp mechanism, and is a substantial departure from conventional operating systems in that it performs synchronization by a general distributed process rollback mechanism. the use of general rollback forces a rethinking of many aspects of operating system design, including programming interface, scheduling, message routing and queueing, storage management, flow control, and commitment.  in this paper we review the mechanics of time warp, describe the twos operating system, show how to construct simulations in object-oriented form to run under twos, and offer a qualitative comparison of time warp to the chandy- misra method of distributed simulation. we also include details of two benchmark simulations and preliminary measurements of time-to-completion, speedup, rollback rate, and antimessage rate, all as functions of the number of processors used.  d. jefferson b. beckman f. wieland l. blume m. diloreto
a practical tool box for system level communication synthesis  this paper presents a practical approach to communication synthesis for hardware/software system specified as tasks communicating through lossless blocking channels. it relies on a limited set of templates that characterize the way data are exchanged between tasks realized either in software or in hardware. the templates are highly portable because their software part is implemented using the posix thread functions, and their hardware part is a hand crafted synthesizable module with a system vci interface.  these interface modules allow simple virtual component reuse since they not only implement protocol compatibility through the use of the system vci/ocb standard but also system level communications through semantics widely accepted in the design community.  denis hommais frederic petrot ivan auge
a flexible compiler structure that allows dynamic phase ordering  traditionally, compilers have been internally organized into separate phases that are invoked in a fixed, predetermined order. however, the optimal phase invocation order is usually different for different contexts, such as (1) large batch-oriented production environments, (2) small batch-oriented student environments, and (3) interactive programming environments.  we discuss the constraints that must be met in order to obtain a compiler with flexible phase ordering, a property that allows the compiler to be designed and implemented without consideration for the intended operating environment. flexible phase ordering allows the compiler to be specially configured after the fact. a production compiler based on this principle is also discussed.  wilf r. lalonde jim des rivieres
unix emacs: a retrospective (lessons for flexible system design)  unix emacs is well-known and widely used as a text editor that has been extended in a remarkable number of directions, not always wisely. because it is programmable in a powerful yet simple programming language, emacs has been used as a development tool for the construction of some remarkably complex user-oriented programs. indeed, it has served as both a user interface management system and a user interface toolkit, though it was designed as neither. in this paper, we discuss the features that have made it so popular for user interface development, in an attempt to derive lessons of value for more powerful and more systematically designed systems in the future.  nathaniel s. borenstein james gosling
interfacing low-level c device drivers with ada 95 the personal computer hardware marketplace has grown rapidly in recent years. many software projects, as a cost-cutting measure, are buying "off-the-self" items to meet heir hardware requirements. almost all of the device drivers for these devices are written in the c programming language. however, the selection of the programming language for the project does not need to be confined to c. this paper details the powerful tools in ada 95, such as pragmas to interface code written in other programming languages to ada 95 applications. an example of a generic real-time ada 95 application interfacing with a low-level c serial device driver is used to aid the reader in the concepts and idea's discussed in the paper. steven doran
discovering machine-specific code improvements  i have designed and built a compiler construction tool that automates much of the case analysis necessary to exploit special purpose instructions on a target machine. given a suitable description of the target machine, my analysis identifies instruction sequences that are equivalent to single instructions. during code generation, these equivalences can be used to avoid inefficient instruction sequences in favor of more efficient instructions.  i present a working prototype of the instruction set analyzer needed in the framework outlined by [giegerich 83]. in contrast to the work presented in [davidson and fraser 80, 84], i analyze machine descriptions during compiler construction, rather than analyzing instruction sequences that occur during code generation. [r kessler 84] describes a system which analyzes machine descriptions during compiler construction, but which which is limited to discovering instructions that are equivalent to instruction sequences of length 2. the techniques presented here can identify instruction sequences of arbitrary length that are equivalent to single instructions.  i have applied this analysis to the descriptions of two machines, and used the results to replace hand-written case analysis routines in an otherwise table- driven code generator [henry 84].  peter b. kessler
fill-in-the-blank jcl: why we did it and how  several years ago, in an effort to simplify our production job process, standardize our production jcl, and live with the installation of a new security package, we developed a system called production job submission control (pjsc). pjsc consists of a small "programming" language and a full- screen interface that prompts for input and then generates job streams using the input.  increasingly, pjsc is not just for our operations staff. it is becoming a tool for use by us, the programming staff, and most important, our users. even complete programs can be generated and/or submitted to the system using this process.  this paper will discuss the underlying concepts of pjsc and present an overview of the implementation which is now run at uab. examples of use and suggestions for development of similar programs for other environments will also be included.  l. manderson
fast breakpoints: design and implementation  we have designed and implemented a fast breakpoint facility. breakpoints are usually thought of as a feature of an interactive debugger, in which case the breakpoints need not be particularly fast. in our environment breakpoints are often used for non- interactive information gathering; for example, procedure call count and statement execution count profiling [swinehart, et al.]. when used non- interactively, breakpoints should be as fast as possible, so as to perturb the execution of the program as little as possible. even in interactive debuggers, a conditional breakpoint facility would benefit from breakpoints that could transfer to the evaluation of the condition rapidly, and continue expeditiously if the condition were not satisfied. such conditional breakpoints could be used to check assertions, etc. program advising could also make use of fast breakpoints [teitelman]. examples of advising include tracing, timing, and even animation, all of which should be part of an advanced programming environment.  we have ported the cedar environment from a machine with microcode support for breakpoints [lampson and pier] to commercial platforms running c code [atkinson, et al.]. most of our ports run under the unix* operating system, so one choice for implementing breakpoints for cedar was to use the breakpoint facility provided by that system. the breakpoints provided by the unix operating system are several orders of magnitude too slow (and also several process switches too complicated) for the applications we have in mind. so we designed a breakpoint system that was fast enough for our purposes.  breakpoints for uni-processors running single threads of control used to be fast and simple to implement. this paper shows that breakpoints can still be fast, even with multiple threads of control on multi-processors. this paper describes problems in the design of a breakpoint package for modern computer architectures and programming styles, and our solutions to them for a particular architecture.  peter b. kessler
simpleio: a java package for novice interactive and graphics programming this paper describes how to incorporate user interactivity and graphics into a first course in computer science. problems and alternative solutions are discussed. a java package called simpleio that we developed is presented. it allows novice programmers to build simple gui -based programs while maintaining good design principles. the package includes methods for requesting data from the user including integers, reals, string and booleans. it also supports simple menus, graphics displays and text file handling. ursula wolz elliot koffman