waashk/acm huggingface dataset:
enforcing trace properties by program transformation  we propose an automatic method to enforce trace properties on programs. the programmer specifies the property separately from the program; a program transformer takes the program and the property and automatically produces another "equivalent" pogram satisfying the property. this separation of concerns makes the program easier to develop and maintain. our approach is both static and dynamic. it integrates static analyses in order to avoid useless transformations. on the other hand, it never rejects programs but adds dynamic checks when necessary. an important challenge is to make this dynamic enforcement as inexpensive as possible. the most obvious application domain is the enforcement of security policies. in particular, a potential use of the method is the securization of mobile code upon receipt.  thomas colcombet pascal fradet
simplegraphics: tcl/tk visualization of real-time multi-threaded and distributed applications visualization of complex software applications is an exciting and challenging field. useful displays are invaluable for developers in analysis of their software systems, and for meaningful system presentations to customers at a higher conceptual level.there have been many notable visualization examples applicable to data centric systems, including the grasp code visualizer[11], the uw illustrating compiler[14], and the information space visualizations embodied in cone trees[7] and data walls[8]. as conceptual and abstraction levels of these advanced graphics increases and becomes more prevalent, and as the real-world applications become more complicated from concurrency and distribution, the interfacing cohesion process becomes more difficult.this paper describes concepts and issues for integrating visualization techniques into multi- threaded and distributed applications, and shows foundation use available across application domains. _simplegraphics_ is a term used in this paper to describe these powerful and rapidly developed visualizations applied to soft real-time applications. for the applications described here to meet the "simple" criteria they must be both conceptually simple and quickly developed - in say under 10 minutes. this leads to their use when appropriate in a "what if" manner, as well as taking them out if no longer needed. looking ahead, the newer embedded devices, such as the _autopc_ or the _palmpilot,_ have a small graphic foot print and will probably not allow for complicated graphics, leading to more use of abstractions like _simplegraphics._newer object oriented concurrency and distribution abstractions are being explored and applied to augment the work since the last international real-time ada workshop (irtaw)[6][5]. with pervasive concurrent and distributed systems under development, it becomes clear that better controls and visualizations techniques are necessary, and ada provides elegant solution techniques that can evolve with changing requirements. the graphic language, tcl/tk[9], is used here both for it's portability and its higher abstraction (through less syntax) supporting rapid development feedback.the benefits and impacts from this work include highlighting multi-threaded real-time issues, showing rapid turnaround through reuse, robust development through objects, better visualization techniques, and techniques for interfacing to other languages. in short, the goals of the 9th irtaw are addressed in various aspects within this body of work. scott arthur moody samuel kwok dale karr
experimental results from dynamic slicing of c programs  program slicing is a program analysis technique that has been studied in the context of several different applications in the construction, optimization, maintenance, testing, and debugging of programs. algorithms are available for constructing slices for a particular execution of a program (dynamic slices), as well as to approximate a subset of the behavior over all possible executions of a program (static slices). however, these algorithms have been studied only in the context of small abstract languages. program slicing is bound to remain an academic exercise unless one can not only demonstrate the feasibility of building a slicer for nontrivial programs written in a real programming language, but also verify that a type of slice is sufficiently thin, on the average, for the application for which it is chosen. in this article, we present results from using slice, a dynamic program slicer for c programs, designed and implemented to experiment with several different kinds of program slices and to study them both qualitatively and quantitatively. several application programs, ranging in size (i.e., number of lines of code) over two orders of magnitude, were sliced exhaustively to obtain average worst-case metrics for the size of program slices.  g. a. venkatesh
portable run-time support for dynamic object-oriented parallel processing  mentat is an object-oriented parallel processing system designed to simplify the task of writing portable parallel programs for parallel machines and workstation networks. the mentat compiler and run-time system work together to automatically manage the communication and synchronization between objects. the run-time system marshals member function arguments, schedules objects on processors, and dynamically constructs and executes large-grain data dependence graphs. in this article we present the mentat run-time system. we focus on three aspects---the software architecture, including the interface to the compiler and the structure and interaction of the principle components of the run-time system; the run-time overhead on a component-by-component basis for two platforms, a sun sparcstation 2 and an intel paragon; and an analysis of the minimum granularity required for application programs to overcome the run-time overhead.  andrew s. grimshaw jon b. weissman w. timothy strayer
debugging standard ml without reverse engineering  we have built a novel and efficient replay debugger for our standard ml compiler. debugging facilities are provided by instrumenting the user's source code; this approach, made feasible by ml's safety property, is machine- independent and back-end independent. replay is practical because ml is normally used functionally, and our compiler uses continuation-passing style; thus most of the program's state can be checkpointed quickly and compactly using call-with- current-continuation. together, instrumentation and replay support a simple and elegant debugger featuring full variable display, polymorphic type resolution, stack trace-back, breakpointing, and reverse execution, even though our compiler is very highly optimizing and has no run- time stack.  andrew p. tolmach andrew w. appel
dsl implementation using staging and monads  the impact of domain specific languages (dsls) on software design is considerable. they allow programs to be more concise than equivalent programs written in a high-level programming languages. they relieve programmers from making decisions about data-structure and algorithm design, and thus allows solutions to be constructed quickly. because dsl's are at a higher level of abstraction they are easier to maintain and reason about than equivalent programs written in a high-level language, and perhaps most importantly they can be written by domain experts rather than programmers.  the problem is that dsl implementation is costly and prone to errors, and that high level approaches to dsl implementation often produce inefficient systems. by using two new programming language mechanisms, program staging and monadic abstraction, we can lower the cost of dsl implementations by allowing reuse at many levels. these mechanisms provide the expressive power that allows the construction of many compiler components as reusable libraries, provide a direct link between the semantics and the low-level implementation, and provide the structure necessary to reason about the implementation.  tim sheard zine-el- abidine benaissa emir pasalic
real-time programming with gnat: specialised kernels versus posix threads the fact that most of the gnat ports are based on non real-time operating systems leads to a reduced usability for developing real-time systems. otherwise, existing ports over real-time operating systems are excessively complex, since gnat uses only a reduced set of their functionality, and with a very specific semantic. this paper describes the implementation of a low-level tasking support for the gnat run-time. in order to achieve a predictable real-time behaviour we have developed a very simple library, built to fit only the gnat tasking requirements. we have also designed a bare machine kernel which provides the minimum environment needed by the upper layers. juan a. de la puente jose f. ruiz jesus m. gonzalez-barahona
dragoon: an object-oriented notation supporting the reuse and distribution ofada softwareamong the more radical proposals for changes to the ada standard in ada9x arethose advocating the introduction of Â"object-orientedÂ" features exemplifiedby languages such as smalltalk and eiffel. dragoon is a language whichsupports the fundamental concepts of object-oriented programming in an adastyle, while retaining most of the features of current ada. in other words itsupports Â"ada-orientedÂ" object-oriented programming. it also employsenhanced forms of multiple inheritance to support concurrency anddistribution. therefore, although not designed specifically as a proposal forthe ada9x project, dragoon may serve as a basis for the development of ada inan Â"object-orientedÂ" direction. this paper provides a brief overview of thelanguage.c. atkinson andrea de maio r. bayan
interprocedural static analysis of sequencing constraints  this paper describes a system that automatically performs static interprocedural sequencing analysis from programmable constraint specifications. we describe the algorithms used for interprocedural analysis, relate the problems arising from the analysis of real-world programs, and show how these difficulties were overcome. finally, we sketch the architecture of our prototype analysis system (called cesar) and describe our experiences to date with its use, citing performance and error detection characteristics.  kurt m. olender leon j. osterweil
improving gang scheduling through job performance analysis and malleability  the openmp programming model provides parallel applications a very important feature: job malleability. job malleability is the capacity of an application to dynamically adapt its parallelism to the number of processors allocated to it. we believe that job malleability provides to applications the flexibility that a system needs to achieve its maximum performance. we also defend that a system has to take its decisions not only based on user requirements but also based on run-time performance measurements to ensure the efficient use of resources. job malleability is the application characteristic that makes possible the run-time performance analysis. without malleability applications would not be able to adapt their parallelism to the system decisions. to support these ideas, we present two new approaches to attack the two main problems of gang scheduling: the excessive number of time slots and the fragmentation. our first proposal is to apply a scheduling policy inside each time slot of gang scheduling to distribute processors among applications considering their efficiency, calculated based on run-time measurements. we call this policy performance-driven gang scheduling. our second approach is a new re-packing algorithm, compress&amp;join;, that exploits the job malleability. this algorithm modifies the processor allocation of running applications to adapt it to the system necessities and minimize the fragmentation and number of time slots. these proposals have been implemented in a sgi origin 2000 with 64 processors. results show the validity and convenience of both, to consider the job performance analysis calculated at run-time to decide the processor allocation, and to use a flexible programming model that adapts applications to system decisions.  julita corbalan xavier martorell jesus labarta
coordinating first-order multiparty interactions  a first-order multiparty interaction is an abstraction mechanism that defines communication among a set of formal process roles. actual processes participate in a first-order interaction by enroling into roles, and execution of the interaction can proceed when all roles are filled by distinct processes. as in csp, enrolement statements can serve as guards in alternative commands. the enrolement guard-scheduling problem then is to enable the execution of first-order interactions through the judicious scheduling of roles to processes that are currently ready to execute enrolement guards.  we present a fully distributed and message-efficient algorithm for the enrolement guard-scheduling problem, the first such solution of which we are aware. we also describe several extensions of the algorithm, including: generic roles; dynamically changing environments, where processes can be created and destroyed at run time; and nested-enrolement, which allows interactions to be nested.  yuh-jzer joung scott a. smolka
test case generation using prolog  for the validation of the kernel system calls of a family of unix 1) systems a knowledge based test environment was conceived. a prototype version is currently implemented in prolog. the knowledge base consists essentially of three parts:  test case specifications of the various system calls,  a test suite generator with predicates including information about unix system properties and sound test practices, and  a test protocol archive including utilities to extract and prepare reports about the test results.  all information in the knowledge base is stored as horn clauses, i.e. facts and rules immediately to be consulted and executed by a prolog interpreter.  herbert pesch peter schnupp hans schaller anton paul spirk
linking programs incrementally  linking is traditionally a batch process that resolves cross-references between object modules and run-time libraries to produce a stand-alone executable image. because most program changes only involve a small part of the program, we have implemented an incremental linker, named inclink, that processes only the changed modules. inclink generates a new executable in time proportional to the size of change; in contrast, a batch linker generates an executable in time proporitonal to the size of the program. to minimize updates to the executable, inclink allocates extra space for every module. by allocating 24 percent more space in the executable for overflows, inclink can update a module in place over 97 percent of the time. measurements show that inclink is more than an order of magnitude faster than the unix [2] batch linker and that 88 percent of all links will take less than 2 s of cpu time on a microvax-2, independent of program size.  russell w. quong mark a. linton
implicit context: easing software evolution and reuse  software systems should consist of simple, conceptually clean software components interacting along narrow, well-defined paths. all too often, this is not reality: complex components end up interacting for reasons unrelated to the functionality they provide. we refer to knowledge within a component that is not conceptually required for the individual behaviour of that component as extraneous embedded knowledge (eek). eek creeps into a system in many forms, including dependences upon particular names and the passing of extraneous parameters. this paper proposes the use of implicit context as a means for reducing eek in systems by combining a mechanism to reflect upon what has happened in a system, through queries on the call history, with a mechanism for altering calls to and from a component. we demonstrate the benefits of implicit context by describing its use to reduce eek in the java swing library.  robert j. walker gail c. murphy
value dependence graphs: representation without taxation  the value dependence graph (vdg) is a sparse dataflow-like representation that simplifies program analysis and transformation. it is a functional representation that represents control flow as data flow and makes explicit all machine quantities, such as stores and i/o channels. we are developing a compiler that builds a vdg representing a program, analyzes and transforms the vdg, then produces a control flow graph (cfg) [asu86] from the optimized vdg. this framework simplifies transformations and improves upon several published results. for example, it enables more powerful code motion than [clz86, fow87], eliminates as many redundancies as [awz88, rwz88] (except for redundant loops), and provides important information to the code scheduler [br91]. we exhibit a fast, one- pass method for elimination of partial redundancies that never performs redundant code motion [kfs92, ds93] and is simpler than the classical [mr79, dha91] or ssa [rwz88] methods. these results accrue from eliminating the cfg from the analysis/transformation phases and using demand dependences in preference to control dependences.  daniel weise roger f. crew michael ernst bjarne steensgaard
orthogonal version management  one part of the "software configuration management" \--- software version control --- is the task of controlling different versions of documents. most existing version control systems accomplish this task by managing variant and revision trees of single documents. the structure of these trees depends on the chronological evolution of the software project. we call this form of organization "intermixed organization" of variants and revisions. this paper points out the disadvantages of that organization, introduces a new way of version management - the "orthogonal organization" \- and then compares the two organizations by means of an example.  c. reichenberger
a gqm-based tool to support the development of software quality measurement plans this paper focuses on the goal-question-metric (gqm) approach, which has been proposed as a goal-oriented approach for the measurement of products and processes in software engineering. first, the gqm is characterized, and then, the _gqm-plan_ tool, is described. the _gqm- plan_ was developed to support the preparation of measuring plans based on gqm. janaina c. abib tereza g. kirner
constraintlisp: an object-oriented constraint programming language  constraintlisp is an object-oriented constraint programming language. it is based on the constraint satisfaction problem (csp) model in artificial intelligence and the object-oriented technology. this integration provides both the declarative representation and efficiency of constraint solving of constraint programming, and the powerful problem modelling capability, maintainability, reusability and extensibility of the object-oriented technology. constraintlisp is aimed at providing practical solutions to real life constrained search problems such as scheduling, resource allocation, etc. it is also designed and implemented in an object-oriented approach.  bing liu yuen-wah ku
the meta4 programming language  meta4 is an object oriented language with first order reasoning capability that also includes reasoning about the _change_ that the classes go through over time, efficient partial evaluation via runtime propagation of specific values, explicit run- time code generation via a source code to machine code compiling engine - not an interpreter.  coupled with a strong encapsulation principle and certain reasonable language restrictions and programmer supplied annotations, meta4 allows all parts of the program, including the compiler itself to be extended and specialized over time. therefore, meta4 is _mutable_. we introduce the concept of _run-time grammar extension_, an elegant and powerful facility for custom- programming of new _language semantics_ at the _grammar level_. in other words, its _semantics_ and _grammar_ can be extended or even modified, even at run time to solve specific problems.  jason w. kim
separating key management from file system security no secure network file system has ever grown to span the internet. existing systems all lack adequate key management for security at a global scale. given the diversity of the internet, any particular mechanism a file system employs to manage keys will fail to support many types of use.we propose separating key management from file system security, letting the world share a single global file system no matter how individuals manage keys. we present sfs, a secure file system that avoids internal key management. while other file systems need key management to map file names to encryption keys, sfs file names effectively contain public keys, making them _self-certifying pathnames._ key management in sfs occurs outside of the file system, in whatever procedure users choose to generate file names.self-certifying pathnames free sfs clients from any notion of administrative realm, making inter-realm file sharing trivial. they let users authenticate servers through a number of different techniques. the file namespace doubles as a key certification namespace, so that people can realize many key management schemes using only standard file utilities. finally, with self-certifying pathnames, people can bootstrap one key management mechanism using another. these properties make sfs more versatile than any file system with built-in key management. david mazières michael kaminsky m. frans kaashoek emmett witchel
efficient implementation of the smalltalk-80 system  the smalltalk-80* programming language includes dynamic storage allocation, full upward funargs, and universally polymorphic procedures; the smalltalk-80 programming system features interactive execution with incremental compilation, and implementation portability. these features of modern programming systems are among the most difficult to implement efficiently, even individually. a new implementation of the smalltalk-80 system, hosted on a small microprocessor- based computer, achieves high performance while retaining complete (object code) compatibility with existing implementations. this paper discusses the most significant optimization techniques developed over the course of the project, many of which are applicable to other languages. the key idea is to represent certain runtime state (both code and data) in more than one form, and to convert between forms when needed.  l. peter deutsch allan m. schiffman