waashk/acm huggingface dataset:
scale and performance in a distributed file system  the andrew file system is a location-transparent distributed tile system that will eventually span more than 5000 workstations at carnegie mellon university. large scale affects performance and complicates system operation. in this paper we present observations of a prototype implementation, motivate changes in the areas of cache validation, server process structure, name translation, and low-level storage representation, and quantitatively demonstrate andrews ability to scale gracefully. we establish the importance of whole-file transfer and caching in andrew by comparing its performance with that of sun microsystems nfs tile system. we also show how the aggregation of files into volumes improves the operability of the system.  john h. howard michael l. kazar sherri g. menees david a. nichols m. satyanarayanan robert n. sidebotham michael j. west
concepts of operational software quality metrics  managers and developers of large software systems need a set of operationally defined measures of software quality. this paper presents metrics that are useful for the estimation of an overall software quality and computation of estimated field values such as the field fault density. the newly-developed algorithms can be applied to estimate the quality of a software whose contents change throughout the period of testing. moreover, the estimation algorithms characterize major and minor software releases separately. the accuracy and reliability of the estimation algorithms are discussed.  amos o. olagunju
escape analysis on lists  higher order functional programs constantly allocate objects dynamically. these objects are typically cons cells, closures, and records and are generally allocated in the heap and reclaimed later by some garbage collection process. this paper describes a compile time analysis, called escape analysis, for determining the lifetime of dynamically created objects in higher order functional programs, and describes optimizations that can be performed, based on the analysis, to improve storage allocation and reclamation of such objects. in particular, our analysis can be applied to programs manipulating lists, in which case optimizations can be performed to allow cons cells in spines of lists to be either reclaimed immediately or reused without incurring any garbage collection overhead. in a previous paper on escape analysis [10], we had left open the problem of performing escape analysis on lists.  escape analysis simply determines when the argument (or some part of the argument) to a function call is returned by that call. this simple piece of information turns out to be sufficiently powerful to allow stack allocation of objects, compile-time garbage collection, reduction of run-time storage reclamation overhead, and other optimizations that are possible when the lifetimes of objects can be computed statically.  our approach is to define a high-level non-standard semantics that, in many ways, is similar to the standard semantics and captures the escape behavior caused by the constructs in a functional language. the advantage of our analysis lies in its conceptual simplicity and portability (i.e. no assumption is made about an underlying abstract machine).  young gil park benjamin goldberg
consistency checking within embedded design languages  it is difficult to ensure consistency between a program's design and its implementation. an embedded design language (one superimposed on an implementation language) can help. this paper describes a particular embedded design language that was successfully used to design and implement a very large compiling system. this design language has a rich set of constructs for expressing the high-level and detailed designs of a program. it also supports various levels of design and implementation consistency checking, and the generation of a variety of documents for use by programmers and reviewers.  a. rudmik b. e. casey h. cohen
comparing fortran compilers users of other, trendier, languages often assume that fortran is an unused relic from a bygone age. however, evidence for its vitality may be found in the large and, apparently, growing number of fortran compilers and tools. one can readily find half a dozen commercial fortran 95 compilers for the intel windows platform, and nearly as many for intel linux. in addition, cheap or free fortran 77 compilers are available from a number of sources.as a service to customers, polyhedron software (a uk-based developer and reseller of products for fortran programmers) has produced a series of charts comparing the features of these compilers. the comparisons cover areas of interest to compiler users, including run-time performance, diagnostics, debugger capabilities, support from third-party libraries and tools, language extensions, gui programming capabilities, and many others. in this short paper, i will describe some of these comparisons. readers are referred to the polyhedron website (http://www.polyhedron.com) for the charts themselves. john appleyard
c++ classes for linking optimization with complex simulations the object- oriented programming paradigm can be used to overcome the incompatibilities between off-the-shelf optimization software and application software. the hilbert class library (hcl) defines the fundamental mathematical objects arising in optimization problems, such as vectors, linear operators, and so forth, as c++ classes, making it possible to write optimization code in a natural fashion, while allowing application software such as simulators to use the most convenient data structures and programming style. in spite of the poor reputation c++ has for runtime performance, the use of mixed-language programming allows performance equal to that achieved by standard fortran packages, as comparisons with the popular code lbfgs and arpack demonstrate. mark s. gockenbach matthew j. petro william w. symes
dynamic software updating  many important applications must run continuously and without interruption, yet must be changed to fix bugs or upgrade functionality. no prior general- purpose methodology for dynamic updating achieves a practical balance between flexibility, robustness, low overhead, and ease of use.  we present a new approach for c-like languages that provides type-safe dynamic updating of native code in an extremely flexible manner (code, data, and types may be updated, at programmer-determined times) and permits the use of automated tools to aid the programmer in the updating process. our system is based on _dynamic patches_ that both contain the updated code and the code needed to transition from the old version to the new. a novel aspect of our patches is that they consist of _verifiable native code_ (_e.g._ proof- carrying code [17] or typed assembly language [16]), which is native code accompanied by annotations that allow on-line verification of the code's safety. we discuss how patches are generated mostly automatically, how they are applied using dynamic-linking technology, and how code is compiled to make it updateable.  to concretely illustrate our system, we have implemented a dynamically- updateable web server, flashed. we discuss our experience building and maintaining flashed. performance experiments show that for flashed, the overhead due to updating is typically less than 1%.  michael hicks jonathan t. moore scott nettles
nondeterministic call by need is neither lazy nor by name  this paper offers a definition of nondeterministic call by need and gives two alternative call by need power domain semantics for a language with mccarthy's ambiguous operator amb. amb is one of the earliest and most interesting nondeterministic programming language constructs [9]. the value of (amb e1 e2) is ambiguously the value of e1 or the value of e2, with one important qualification: if the value of e1 is undefined then the value of (amb e1 e2) is the value of e2, and vice versa. for example the parallel or of e1 and e2 can be written as  (amb (if e1 true e2)  (if e2 true e1)),  showing the usefulness of amb even for writing deterministic expressions.  william clinger
deciding type equivalence in a language with singleton kinds  work on the tilt compiler for standard ml led us to study a language with singleton kinds: s(a) is the kind of all types provably equivalent to the type a. singletons are interesting because they provide a very general form of definitions for type variables, allow fine-grained control of type computations, and allow many equational constraints to be expressed within the type system.  internally, tilt represents programs using a predicative variant of girard's fω enriched with singleton kinds, dependent product and function kinds ( and ), and a sub-kinding relation. an important benefit of using a typed language as the representation of programs is that typechecking can detect many common compiler implementation errors. however, the decidability of typechecking for our particular representation is not obvious. in order to typecheck a term, we must be able to determine whether two type constructors are provably equivalent. but in the presence of singleton kinds, the equivalence of type constructors depends both on the typing context in which they are compared and on the kind at which they are compared.  in this paper we concentrate on the key issue for decidability of typechecking: determining the equivalence of well-formed type constructors. we define the λ s< subscrpt>< calculus, a model of the constructors and kinds of tilt's intermediate language. inspired by coquand's result for type theory, we prove decidability of constructor equivalence for λ s< subscrpt>≤ by exhibiting a novel --- though slightly inefficient --- type-directed comparison algorithm. the correctness of this algorithm is proved using an interesting variant of kripke-style logical relations: unary relations are indexed by a single possible world (in our case, a typing context), but binary relations are indexed by two worlds. using this result we can then show the correctness of a natural, practical algorithm used by the tilt compiler.  christopher a. stone robert harper
eliminating redundancies in sum-of-product array computations  array programming languages such as fortran 90, high performance fortran and zpl are well-suited to scientific computing because they free the scientist from the responsibility of managing burdensome low-level details that complicate programming in languages like c and fortran 77. however, these burdensome details are critical to performance, thus necessitating aggressive compilation techniques for their optimization. in this paper, we present a new compiler optimization called array subexpression elimination (ase) that lets a programmer take advantage of the expressibility afforded by array languages and achieve enviable portability and performance. we design a set of micro- benchmarks that model an important class of computations known as stencils and we report on our implementation of this optimization in the context of this micro-benchmark suite. our results include a 125% improvement on one of these benchmarks and a 50% average speedup across the suite. also we show a speedup of 32% improvement on the zpl port of the nas mg parallel benchmark and a 29% speedup over the hand-optimized fortran version. further, the compilation time is only negligibly affected.  steven j. deitz bradford l. chamberlain lawrence snyder
avcs: the apl version control system  this paper described avcs, which is an apl-oriented version control system devised as a tool to track the history of software projects and to control concurrent access to project components. the basics of version control systems are explained, and specific aspects of applying a version control system methodology to project development in apl environments are considered. particular attention is given to features which differentiate the approach accepted in avcs from that of available version control and project management systems. specification of avcs's data maintenance, programming and user interface is presented to the extent required in order to explain how the system works. in conclusion, the possible application of avcs to solving problems of porting apl projects across different environments is outlined.  nikolai i. puntikov maxim a. volodin alexei a. kolesnikov
laboratory experiment with the 3rolesplaying method the paper addresses the problem of making experiments for software engineering during laboratories. there is a need for experimental investigations. if experiments are performed in the lab together with training they must also have high educational value. in the paper, there is discussion about joining education and research. then summary of the 3rolesplaying method which satisfies goals of both of them is presented. results of an experiment that took place in the technical university of gdansk, poland in the summer semester of 1997/98 are described, and verification of the results value is made. anna bobkowska
on performance and space usage improvements for parallelized compiled apl code loop combination has been a traditional optimization technique employed in apl compilers, but may introduce dependencies into the combined loop. we propose an analysis method by which the compiler can keep track of the change of the parallelism when combining high-level primitives. the analysis is necessary when the compiler needs to decide a trade-off between more parallelism and a further combination. we also show how the space usage, as well as the performance, improves by using system calls with the aid of garbage collection to implement a dynamic memory allocation. a modification of the memory management scheme can also increase available parallelism. our experimental results indicate that the performance and the space usage improve appreciably with the above enhancements. dz-ching ju wai-mee ching chuan-lin wu
assertive comments in apl programming  current practice in apl programming (and in most other languages) is to use comments to describe what is intended by subsequent lines within a function. an alternative approach to commenting is described, wherein assertions (a concept borrowed from program proof techniques) are inserted into apl code, specifying the present state of relevant variables, etc. it is shown that this approach is especially appropriate for apl, as most apl design is accomplished by working from a desired end result, backwards.  david m. weintraub
program slicing  program slicing is a method used by experienced computer programmers for abstracting from programs. starting from a subset of a program's behavior, slicing reduces that program to a minimal form which still produces that behavior. the reduced program, called a "slice", is an independent program guaranteed to faithfully represent the original program within the domain of the specified subset of behavior.  finding a slice is in general unsolvable. a dataflow algorithm is presented for approximating slices when the behavior subset is specified as the values of a set of variables at a statement. experimental evidence is presented that these slices are used by programmers during debugging. experience with two automatic slicing tools is summarized. new measures of program complexity are suggested based on the organization of a program's slices.  mark weiser
a practical method for code generation based on exhaustive search  an original method for code generation has been developed in conjunction with the construction of a compiler for the c programming language on the dec-10 computer. the method is comprehensive, determining evaluation order and doing register allocation and instruction selection simultaneously. it uses exhaustive search rather than heuristics, and is table-driven, with most machine-specific information isolated in the tables. testing and evaluation have shown that the method is effective, that the search process is not too time consuming, and that the compiler is capable of producing code as good as that of other optimizing compilers.  david w. krumme david h. ackley
hybrid global/local search strategies for dynamic voltage scaling in embedded multiprocessors  in this paper, we explore a hybrid global/local search optimization framework for dynamic voltage scaling in embedded multiprocessor systems. the problem is to find, for a multiprocessor system in which the processors are capable of dynamically varying their core voltages, the optimum voltage levels for all the tasks in order to minimize the average power consumption under a given performance constraint. an effective local search approach for static voltage scaling based on the concept of a _period graph_ has been demonstrated in [1]. to make use of it in an optimization problem, the period graph must be integrated into a global search algorithm. _simulated heating_, a general optimization framework developed in [19], is an efficient method for precisely this purpose of integrating local search into global search algorithms. however, little is known about the management of computational (compile-time) resources between global search and local search in hybrid algorithms, such as those coordinated by simulated heating. in this paper, we explore various hybrid search management strategies for power optimization under the framework of simulated heating. we demonstrate that careful search management leads to significant power consumption improvement over add-hoc global search / local search integration, and explore alternative approaches to performing hybrid search management for dynamic voltage scaling.  neal k. bambha shuvra s. bhattacharyya jurgen teich eckart zitzler
software quality assessment technology  necessities for software quality measurement and assurance technology have been increased.  b. boehm and mccall proposed software evaluation criteria. based on these studies, g. murine developed software quality metrics (sqm).  sqm was applied to several projects in nec experimentally. an outline of the experiment will be presented and the results discussed.  software quality measurement and assurance technology (sqmat) was developed in nec as a total technology for applying to various types and size of software projects, throughout the software life cycle.  toshihiko sunazuka motoei azuma noriko yamagishi
toward a theory of maximally concurrent programs (shortened version)  typically, program design involves constructing a program p that implements a given specification s; that is, the set p of executions of p is a subset of the set s of executions satisfying s. in many cases, we seek a program p that not only implements s, but for which p = s. then, every execution satisfying the specification is a possible execution of the program; we then call p maximal for the specification s. we argue that maximality is an important criterion in the context of designing concurrent programs because it disallows implementations that do not exhibit enough concurrency. in addition, a maximal solution can serve as a basis for deriving a variety of implementations, each appropriate for execution on a specific computing platform.  this paper also describes a method for proving the maximality of a program with respect to a given specification. even though we prove facts about possible executions of programs, there is no need to appeal to branching time logics; we employ a fragment of linear temporal logic for our proofs. the method results in concise proofs of maximality for several non-trivial examples. the method may also serve as a guide in constructing maximal programs.  rajeev joshi jayadev misra
mi - an object oriented environment for integration of scientific applications  scientific and engineering software is often produced by integration of existing software components of the size of a whole program. however, on the average, scientific software was not developed for reusability and is quite distant from the user model of the application problem; integration and retrofitting is as such a costly process. an architecture, methodology and several c++ class libraries for supporting integration are introduced. the architecture separates a software component layer, and an integration layer. the latter in based on the concept of software model, that is an abstraction of components and a representation of the system differing from its actual physical structure. the methodology is based on matching needs with existing models. the c++ class libraries are explained in some detail. the application to two major systems is analysed and the ideas behind seven other systems are briefly outlined. some lessons learned are summarised in the conclusions.  andrea spinelli paolo salvaneschi mauro cadei marino rocca
data abstraction in glisp  glisp is a high-level language that is based on lisp and is compiled into lisp. it provides a versatile abstract- data-type facility with hierarchical inheritance of properties and object- centered programming. the object code produced by glisp is optimized, so that it is about as efficient as handwritten lisp. an integrated programming environment is provided, including editors for programs and data-type descriptions, interpretive programming features, and a display-based inspector/editor for data. glisp is fully implemented.  gordon s. novak
embedding security policies into a distributed computing environment this paper discusses the implementation of security policies in multipolicy systems. multipolicy systems are systems supporting a multitude of security policies, each policy governing the applications within its own and precisely defined security domain.the paper argues that within multipolicy systems, traditional approaches for implementing security policies such as security kernels are both too weak and too strong. in order to support this thesis, we will discuss architectural issues of the implementation of policy separation, policy persistency, total mediation and putting off-the-shelf applications under the control of security policies. whenever our statements are illustrated by examples, these examples are taken from a case study we implemented for the osf distributed computing environment. udo halfmann winfried e. kuhnhauser
protecting internal state variables from subclasses the use of child packages to encapsulate derived tagged types and their operations should protect the state variables of the parent type that are to be manipulated by the parent operations alone. this protection can be achieved through the declaration of a data component of a limited record type, previously declared with no attributes and an access type discriminant that visibly points to an incomplete definition. the details of the data component (either scalar or composite, depending on application), whose full type declaration is in the parent package body, is accessible only through the discriminant from within the package body. this mechanism provides full information hiding of the details and maximum protection of the contents of those instance variables. susan fife dorchak s. rollins guild