waashk/acm huggingface dataset:
distinguishing the potential operands in fortran programs  there are several possible relationships between the number of potential operands and the actual operands used which correlate with available data (such as akiyama's debugging data). however, additional data is required to distinguish between these hypotheses. since there is a large body of programs available written in fortran, we wish to develop a mechanical counting procedure to enumerate potential operands in fortran programs.  we are currently developing counting rules for these potential operands. sub- routine parameters and input/output variables are relatively easy to identify. however, a number of fortran features, such as common blocks and equivalence'd variables introduce serious complications. some additional analysis of usage or heuristic approaches are required to differentiate potential operands in these situations.  george e. estes
energy-aware adaptation for mobile applications in this paper, we demonstrate that a collaborative relationship between the operating system and applications can be used to meet user-specified goals for battery duration. we first show how applications can dynamically modify their behavior to conserve energy. we then show how the linux operating system can guide such adaptation to yield a battery-life of desired duration. by monitoring energy supply and demand, it is able to select the correct tradeoff between energy conservation and application quality. our evaluation shows that this approach can meet goals that extend battery life by as much as 30%. jason flinn m. satyanarayanan
unexpected side effects of inline substitution: a case study  the structure of a program can encode implicit information that changes both the shape and speed of the generated code. interprocedural transformations like inlining often discard such information; using interprocedural data-flow information as a basis for optimization can have the same effect.  in the course of a study on inline substitution with commercial fortran compilers, we encountered unexpected performance problems in one of the programs. this paper describes the specific problem that we encountered, explores its origins, and examines the ability of several analytical techniques to help the compiler avoid similar problems.  keith d. cooper mary w. hall linda torczon
stack caching for interpreters  an interpreter can spend a significant part of its execution time on accessing arguments of virtual machine instructions. this paper explores two methods to reduce this overhead for virtual stack machines by caching top-of-stack values in (real machine) registers. the dynamic method is based on having, for every possible state of the cache, one specialized version of the whole interpreter; the execution of an instruction usually changes the state of the cache and the next instruction is executed in the version corresponding to the new state. in the static method a state machine that keeps track of the cache state is added to the compiler. common instructions exist in specialized versions for several states, but it is not necessary to have a version of every instruction for every cache state. stack manipulation instructions are optimized away.  m. anton ertl
a modular verifiable exception handling mechanism  this paper presents a new model for exception handling, called the replacement model. the replacement model, in contrast to other exception-handling proposals, supports all the handler responses of resumption, termination, retry, and exception propagation, within both statements and expressions, in a modular, simple, and uniform fashion. the model can be embedded in any expression-oriented language and can also be adapted to languages which are not expression oriented with almost all the above advantages. this paper presents the syntactic extensions for embedding the replacement model into algol 68 and its operational semantics. an axiomatic semantic definition for the model can be found in [27].  shaula yemini daniel m. berry
object-oriented development of integrated programming environments with asdl  asdl is a metalanguage for specifying integrated programming environments as specializations and extensions of a language independent environment kernel. the language combines syntax-directed translation schemes with an object- oriented 'type system. the type system supports data abstraction and multiple inheritance, thus encouraging extensibility, combination and reusability. translation schemes are identified with generic manipulation operations associated with object types that allow the convenient and concise definition of (a) structural mappings between objects types and (b) message propagation along the structure of objects. type and scheme definitions are compiled into executable code which is linked to a language independent environment kernel.  bernd krämer heinz-wilhelm schmidt
procol: a parallel object language with protocols  procol is a parallel c-based object-oriented language with communication based on one-way synchronous messages. objects execute in parallel unless engaged in communication. communication partners are defined by object instance identifiers, or by type. therefore send-receive mappings may be 1-1, n-1, or 1-n, though only 1 message is transferred. procol controls object access by a novel concept: an explicit per-object protocol. this protocol is a specification of the occurrence and sequencing of the communication between the object and its partners. thus protocols support structured, safer and potentially verifiable information exchange between objects. protocols also act as a composition rule over client objects, thereby offering a 'part-of' hierarchy of these cooperating objects.  j. van den bos c. laffra
the uml rules the unified modelling language (uml), version 1.0, developed in order to standardise different object oriented development practices, offers a general way of representing technical, business and software models through the structure and dynamics of the uml modelling elements. the uml also defines a set of rules that are expected to be followed in order to claim that the uml is being followed. in this paper i extract the rules related to the core concepts, and structural and behavioural elements, found in the semantics of the uml documentation set. radmila juric
the mesa programming environment  people everywhere are developing multi-window, integrated programming environments for their favorite computers and languages. this paper describes the mesa programming facilities of the xerox development environment (xde). it is interesting for several reasons. it has existed in something similar to its current form for about 5 years. it has more than 500 users, many interacting with it 8 or more hours a day. several million lines of code have been written by these users, including large, multi-author systems.  previous papers have dealt with the mesa language [geschke77, mitchell79], the operating system [redell79, lampson80] and the processor architecture on which it runs [johnsson82, sweet82]. this paper describes the programming environment: the user illusion, the set of programming tools, and the facilities available for augmenting the environment. section 2 gives a short history of the environment, including some of our original design goals. section 3 describes the current state of the user interface and discusses a few of the schemes that were tried and discarded. section 4 describes some of the program development tools available and discusses how features of the language have influenced their design, and indeed influenced what tools are in the set. section 5 describes other tools that, although valuable to the programming task, are largely language independent. section 6 talks about how easy it is to make additions to the system, and gives examples of user additions---some that modify the environment and some that simply provide new tools. section 7 discusses what we feel are major successes and what we feel needs to be done in the future.  richard e. sweet
the implementation of a coherent memory abstraction on a numa multiprocessor: experiences with platinum  platinum is an operating system kernel with a novel memory management system for non-uniform memory access (numa) multiprocessor architectures. this memory management system implements a coherent memory abstraction. coherent memory is uniformly accessible from all processors in the system. when used by applications coded with appropriate programming styles it appears to be nearly as fast as local physical memory and it reduces memory contention. coherent memory makes programming numa multiprocessors easier for the user while attaining a level of performance comparable with hand-tuned programs.  this paper describes the design and implementation of the platinum memory management system, emphasizing the coherent memory. we measure the cost of basic operations implementing the coherent memory. we also measure the performance of a set of application programs running on platinum. finally, we comment on the interaction between architecture and the coherent memory system.  platinum currently runs on the bbn butterfly plus multiprocessor.  a. cox r. fowler
a concurrent object-oriented knowledge representation language orient84/k: its features and implementation  orient84/k is an object oriented concurrent programming language for describing knowledge systems. in orient84/k, an object is composed of the behavior part, the knowledge-base part, and the monitor part, in order to provide object-oriented, logic-based, demon-oriented, and concurrent- programming paradigms in the object framework. every object is capable of concurrent execution in orient84/k.  in this paper, after describing an overview of orient84/k, we will describe implementation issues in a concurrent object oriented language. then, a new method for an efficient implementation of concurrent objects is proposed and formally described. a new virtual machine for orient84/k is designed using this method, and some preliminary results of evaluation are presented.  yutaka ishikawa mario tokoro
bounded quantifiers have interval models  we propose a sound model for an extension of the language fun, proposed by l. cardelli and p. wegner as a formalization of the notion of inheritance in the context of higher order polymorphic functional 1anguages. the model is obtained by modifying the interval model proposed by r. cartwright, in order to accommodate bounded quantifiers and to obtain a sound structure. our extension of the language supports also a general recursion operator for functions (but not for types).  simon martini
scheduling multithreaded computations by work stealing  this paper studies the problem of efficiently schedulling fully strict (i.e., well- structured) multithreaded computations on parallel computers. a popular and practical method of scheduling this kind of dynamic mimd-style computation is "work stealing," in which processors needing work steal computational threads from other processors. in this paper, we give the first provably good work-stealing scheduler for multithreaded computations with dependencies.  specifically, our analysis shows that the expected time to execute a fully strict computation on p processors using our work-stealing scheduler is t1/ ;p \\+ o(t ∞ , where t1 is the minimum serial execution time of the multithreaded computation and (t ∞ is the minimum execution time with an infinite number of processors. moreover, the space required by the execution is at most s& lt;subscrpt>1p, where s1 is the minimum serial space requirement. we also show that the expected total communication of the algorithm is at most o(_pt ∞ ( 1 + nd)smax), where smax is the size of the largest activation record of any thread and nd is the maximum number of times that any thread synchronizes with its parent. this communication bound justifies the folk wisdom that work- stealing schedulers are more communication efficient than their work-sharing counterparts. all three of these bounds are existentially optimal to within a constant factor.  robert d. blumofe charles e. leiserson
graphical representation of programs in a demonstrational visual shell - an empirical evaluation  an open question in the area of programming by demonstration (pbd) is how to best represent the inferred program. without a way to view, edit, and share programs, pbd systems will never reach their full potential. we designed and implemented two graphical representation languages for a pbd desktop similar to the apple macintosh finder. although a user study showed that both languages enabled nonprogrammers to generate and comprehend programs, the study also revealed that the language that more closely reflected the desktop domain doubled users' abilities to accurately generate programs. trends suggest that the same language was easier for users to comprehend. these findings suggest that it is possible for a pbd system to enable nonprogrammers to construct programs and that the form of the representation can impact the pbd system's effectiveness. a paper-and-pencil evaluation of the two versions of the pbd desktop prior to the study supported these finding and provided interesting feedback on the interaction between usability evaluations and user studies. in particular, the comparison of the paper-and-pencil evaluation with the empirical evaluation suggested that nonempirical evaluation techniques can provide guidance into how to interpret empirical data and, in particular, that pbd systems need to provide support for programming-strategy selection in order to be successful.  francesmary modugno albert t. corbett brad a. myers
database theory for supporting specification-based database system development  we report on the development of a formal theory of databases designed to support specification-based development of database systems. this theory formalizes database systems which include non-first normal form relations, complex integrity constraints, transactions, and embedded data types such as integers, character strings, and user-defined types. our theory is based on two axiomatized algebras (abstract data types) and is being used to mechanically prove the properties of relational algebra and functional dependencies, as well as the relationships between integrity constraints and the primitive operations on databases, e. g., inserts and deletes of tuples. we are also using the theory to prove whether or not specific transactions obey complex integrity constraints which can include universal and existential quantifiers. the latter proofs (as well as failed attempts at proofs) can be used during the design of specific systems and in the optimization of system implementations.  david stemple tim sheard
producers and consumers views of software quality (panel session)  at this very acm workshop/symposium indicates, software quality is of great concern to both producers and users of software. it should be obvious to those who have attended the earlier sessions today and to those who will attend the sessions tomorrow that quality is something that cannot be tested into a system or added to a system. it must be integral from the start of the definition of the system's requirements through each phase of analysis, design, implementation, integration, testing, and installation.  software quality implies an engineering type approach to the development of software. it implies the use of a disciplined development environment, and the use of tools and techniques to provide assurances throughout the software development process that both the software and its baseline specifications are complete, consistent, and traceable from one to another.  peter gross
generating mc68000 code for ada  we adapted the code generator of the karlsruhe ada compiler to produce symbolic mc68000 code. the essential part of the code generator - the code selection phase - is produced automatically by the code generator synthesis system (cgss) out of a formal description of the target machine. therefore our main task consisted of writing a target machine description (tmd) for the motorola mc68000. in this paper we report our experience made in writing the target machine description and in adapting the whole code generator.  hans-stephan jansohn rudolf landwehr jochen hayek michael thätner
using regular approximations for generalisation during partial evalution  on-line partial evaluation algorithms include a generalisation step, which is needed to ensure termination. in partial evaluation of logic and functional programs, the usual generalisation operation applied to computation states is the most specific generalisation (_msg_) of expressions. this can cause loss of information, which is especially serious in programs whose computations first build some internal data structure, which is then used to control a subsequent phase of execution - a common pattern of computation. if the size of the intermediate data is unbounded at partial evaluation time then the _msg_ will lose almost all information about its structure. hence the second phase of computation cannot be effectively specialised.  in this paper a generalisation based on regular approximations is presented. regular approximations are recursive descriptions of term structure closely related to tree automata. a regular approximation of computation states can be built during partial evaluation. the critical point is that when generalisation is performed, the upper bound on regular descriptions can be combined with the _msg_, thus preserving structural information including recursively defined structure. the domain of regular approximations is infinite and hence a widening is incorporated in the generalisation to ensure termination. an algorithm for partial evaluation of logic programs, enhanced with regular approximations, along with some examples of its use will be presented.  john p. gallagher julio c. peralta
combining contracts and exemplar-based programming for class hiding and customization  for performance reasons, client applications often need to influence the implementation strategies of libraries whose services they use. if an object- oriented library contains multiple service classes customized for different usage patterns, applications can influence service implementations by instantiating the customized classes that match their needs. however, with many similar service classes, it can be difficult for applications to determine which classes to instantiate. choosing the wrong class can result in very subtle errors since a customized class might use optimizations that work only over a restricted domain. in this paper, we show how client-side software contracts and exemplar-based class factories can be used to construct customized server objects. by expressing priorities and requirements in contracts, clients can delegate service class selection to the library and thereby avoid implicit dependencies on the library implementation. we have used this approach in the implementation of a real-time database system.  victor b. lortz kang g. shin
trap-driven simulation with tapeworm ii  tapeworm ii is a software- based simulation tool that evaluates the cache and tlb performance of multiple-task and operating system intensive workloads. tapeworm resides in an os kernel and causes a host machine's hardware to drive simulations with kernel traps instead of with address traces, as is conventionally done. this allows tapeworm to quickly and accurately capture complete memory referencing behavior with a limited degradation in overall system performance. this paper compares trap-driven simulation, as implemented in tapeworm, with the more common technique of trace-driven memory simulation with respect to speed, accuracy, portability and flexibility.  richard uhlig david nagle trevor mudge stuart sechrest
the base-rate fallacy and the difficulty of intrusion detection  many different demands can be made of intrusion detection systems. an important requirement is that an intrusion detection system be effective; that is, it should detect a substantial percentage of intrusions into the supervised system, while still keeping the false alarm rate at an acceptable level. this article demonstrates that, for a reasonable set of assumptions, the false alarm rate is the limiting factor for the performance of an intrusion detection system. this is due to the base-rate fallacy phenomenon, that in order to achieve substantial values of the bayesian detection rate p(intrusion***alarm), we have to achieve a (perhaps in some cases unattainably) low false alarm rate. a selection of reports of intrusion detection performance are reviewed, and the conclusion is reached that there are indications that at least some types of intrusion detection have far to go before they can attain such low false alarm rates.  stefan axelsson
synchronizing clocks in the presence of faults  algorithms are described for maintaining clock synchrony in a distributed multiprocess system where each process has its own clock. these algorithms work in the presence of arbitrary clock or process failures, including "two- faced clocks" that present different values to different processes. two of the algorithms require that fewer than one-third of the processes be faulty. a third algorithm works if fewer than half the processes are faulty, but requires digital signatures.  leslie lamport p. m. melliar-smith
techniques for obtaining high performance in java programs  this survey describes research directions in techniques to improve the performance of programs written in the java programming language. the standard technique for java execution is interpretation, which provides for extensive portability of programs. a java interpreter dynamically executes java bytecodes, which comprise the instruction set of the java virtual machine (jvm). execution time performance of java programs can be improved through compilation, possibly at the expense of portability. various types of java compilers have been proposed, including just-in-time (jit) compilers that compile bytecode into native processor instructions on the fly; direct compilers that directly translate the java source code into the target processor's native language; and bytecode-to-source translators that generate either native code or an intermediate language, such as c, from the bytecodes. additional techniques, including bytecode optimization, dynamic compilation, and executing java programs in parallel, attempt to improve java run-time performance while maintaining java's portability. another alternative for executing java programs is a java processor that implements the jvm directly in hardware. in this survey, we discuss the basis features, and the advantages and disadvantages, of the various java execution techniques. we also discuss the various java benchmarks that are being used by the java community for performance evaluation of the different techniques. finally, we conclude with a comparison of the performance of the alternative java execution techniques based on reported results.  iffat h. kazi howard h. chen berdenia stanley david j. lilja
a reuse approach based on object orientation: its contributions in the development of case tools  the aim of this paper is to present an approach to facilitate reuse. this approach, which is based on an object oriented design method, describes a way of structuring components and reuse library.  two concepts, domain and theme, are introduced to allow a classification of components by the services that they offer and by application domain. the library itself is organized in three hierarchical levels -general, dedicated and personal-, where the reusable components are stored according to their degree of "interest" (general interest, by application type or particular). so, the library is generic and could cluster various reusable component types (specification components, design components, packages,…).  the contributions of this approach in the development of case tools are also emphasized.  henda hadjami ben ghezala farouk kamoun