waashk/acm huggingface dataset:
interprocedural optimization: eliminating unnecessary recompilation  while efficient new algorithms for interprocedural data flow analysis have made these techniques practical for use in production compilation systems, a new problem has arisen: collecting and using interprocedural information in a compiler introduces subtle dependences among the procedures of a program. if the compiler depends on interprocedural information to optimize a given module, a subsequent editing change to another module in the program may change the interprocedural information and necessitate recompilation. to avoid having to recompile every module in a program in response to a single editing change to one module, we must develop techniques to more precisely determine which compilations have actually been invalidated by a change to the program's source. this paper presents a general recompilation test to determine which procedures must be compiled in response to a series of editing changes. three different implementation strategies, which demonstrate the fundamental tradeoff between the cost of analysis and the precision of the resulting test, are also discussed.  keith d. cooper ken kennedy linda lorczon
new software engineering programs - worldwide (panel session)  as the growth in value and importance of the software component in virtually all industrial products accelerates, the efficiency with which software is constructed, and its quality, become vital for the entire industry --- high technology or not. in response, new concentrated efforts have been recently created in europe, asia, north and south america, established and owned by private enterprise or government. it seems that these institutes, or programs within new institutes, place themselves between academic research and advanced development, and plan significant experimental work.  the panel will examine the strategies and planned approaches of eight such programs. brief descriptions of some of them follow.  laszlo a. belady nico haberman lim swee say john elmore w. m. murray r. w. witty k. kishida fuad gattaz sobrinho
a new program structure to improve accuracy and readability of pascal software  based on an analysis of errors in a piece of pascal software a new language feature is introduced to increase the degree of compile time checking of program logic and thus improve the confidence of the programmer in the correctness of a program. specifically this involves a form of abstract data type, augmented by restrictions on the use of operations provided with the type, and a means of allowing the programmer to bring logically related segments of program together textually.  w. j. rogers
incremental software test approach for dod-std-2167a ada projects  one of the key challenges for large ada software projects is to define and execute an efficient, cost effective, bounded test program that results in a quality product that meets all customer software requirements. this is particularly challenging in the current climate of government fixed price contracts. the command center processing and display system replacement (ccpds-r) project is being developed entirely in ada by trw for the u.s. air force on a fixed price basis. to mitigate downstream test risks, trw has defined an incremental test approach that satisfies trw and government objectives for informal development/integration testing and for formal requirements verification. features of ada are employed to create a software architecture that supports an incremental test philosophy and contributes to reduced integration effort and risk. the resulting test approach conforms to dod-std-2167a standards.  m. springman
a framework for call graph construction algorithms a large number of call graph construction algorithms for object-oriented and functional languages have been proposed, each embodying different tradeoffs between analysis cost and call graph precision. in this article we present a unifying framework for understanding call graph construction algorithms and an empirical comparison of a representative set of algorithms. we first present a general parameterized algorithm that encompasses many well-known and novel call graph construction algorithms. we have implemented this general algorithm in the vortex compiler infrastructure, a mature, multilanguage, optimizing compiler. the vortex implementation provides a "level playing field" for meaningful cross-algorithm performance comparisons. the costs and benefits of a number of call graph construction algorithms are empirically assessed by applying their vortex implementation to a suite of sizeable (5,000 to 50,000 lines of code) cecil and java programs. for many of these applications, interprocedural analysis enabled substantial speed-ups over an already highly optimized baseline. furthermore, a significant fraction of these speed-ups can be obtained through the use of a scalable, near-linear time call graph construction algorithm. david grove craig chambers
generic packages in c  the structuring achieved by generic packages in ada can be cheaply emulated in c by judicious use of the preprocessor. two files are required for the generic package: the specification and the body. two more files are used in the instantiation: one holding the instantiation parameters and one with auxiliary code. instantiation results in normal c header and object files (*.h and *.0). dependency control can be delegated *** the make program.  dick grune
managing variability in software architectures  this paper presents experience with explicitly managing variability within a software architecture. software architects normally plan for change and put mechanisms in the architecture to support those changes. understanding the situations where change has been planned for and recording the options possible within particular situations is usually not done explicitly. this becomes important if the architecture is used for many product versions over a long period or in a product line context where the architecture is used to build a variety of different products. that is, it is important to explicitly represent variation and indicate within the architecture locations for which change has been allowed.  we will describe how the management of variations in an architecture can be made more explicit and how the use of variation points connected to the choices a customer has when ordering a product can help to navigate to the appropriate places in the architecture.  felix bachmann len bass
software sizing problems in software engineering metrics  effort estimation models such as cocomo (constructive cost model) or copmo (cooperative programming model) typically use kdsi (thousands of delivered source instructions) as the primary input variable to determine person-months and development time for software development projects. such models have the general form [boe81], [con86]: e = @@@@ where n = number of modules e = effort, in man-months (mm) s = software sizing estimate (kdsi) a,b = development mode constants c1 = complexity multipliers based upon project conditions  a great deal of research has been conducted on effort model validation using databases of actual performance for a variety of projects, but little research has been reported on improving the quality of the original sizing estimates.  pert-type loc (lines of code) sizing estimates have been suggested which utilize the activity-time mean and variance estimation equations used in pert networks to estimate the mean and variance of module size for a sub-divided software product [boe81]. these equations have been used in project management for almost thirty years, but were the subject of a great deal of criticism regarding their theoretical foundation, especially regarding the assumption of such a narrowly constrained beta distribution [cla62], [gru62], [mac64].  research has shown that more reliable estimates of the moments of pert-type distributions, especially of the variance, may be obtained by using percentile estimates rather than "end-point" estimates for the optimistic and pessimistic values. fifth and ninety-fifth percentile estimates lead to moment calculations which are robust to variations in the shape of the distribution [mod68]. it has also been found that these percentile estimates correspond more closely to the actual estimates obtained when asking for end points.  variations to the pert estimation equations which use these percentile estimates for module size instead of the standard end- point estimates are recommended: s1 = (a′1 \\+ 4m1 \\+ b′1) /6 21 = (b′1 -a′1 )2/10.2 where s1 = mean module size in kdsi 21 = variance of module size a′ = 5th-percentile module size m = most likely module size b′ = 95th-percentile module size  overall project size and variance would follow the typical pert approach by summing the module mean and variance over the entire software product: s = @@@@ v = @@@@  the project standard deviation could then be used to compute an upper confidence interval of s for model input to determine the desired level of confidence in the forecasted effort.  an example of software sizing in the cocomo environment is demonstrated using the revised pert equations. effort forecasts calculated with these estimates are compared with the results using standard pert sizing. recommendations for additional research in improving effort forecasting are also presented.  edward g. rodgers
a framework for efficient reuse of binary code in java  this paper presents a compilation framework that enables efficient sharing of executable code across distinct java virtual machine (jvm) instances. high- performance jvms rely on run-time compilation, since static compilation cannot handle many dynamic features of java. these jvms suffer from large memory footprints and high startup costs, which are serious problems for embedded devices (such as hand held personal digital assistants and cellular phones) and scalable servers. a recently proposed approach called quasi-static compilation overcomes these difficulties by reusing precompiled binary images after performing validation checks and stitching on them (i.e., adapting them to a new execution context), falling back to interpretation or dynamic compilation whenever necessary. however, the requirement in our previous design to duplicate and modify the executable binary image for stitching is a major drawback when targeting embedded systems and scalable servers. in this paper, we describe a new approach that allows stitching to be done on an indirection table, leaving the executable code unmodified and therefore writable to read- only memory. on embedded devices, this saves precious space in writable memory. on scalable servers, this allows a single image of the executable to be shared among multiple jvms, thus improving scalability. furthermore, we describe a novel technique for dynamically linking classes that uses _traps_ to detect when a class should be linked and initialized. like back-patching, the technique allows all accesses after the first to proceed at full speed, but unlike back-patching, it avoids the modification of running code. we have implemented this approach in the quicksilver quasi- static compiler for the jalape~ no jvm. on the specjvm98 benchmark suite, our approach obtains code space savings, in writable memory, of between 82% to 89% of that from our previous quasi-static compiler, while delivering performance that is typically within 1% to 7% of that approach, and which is competitive with the performance of the jalapeño adaptive optimization system.  pramod g. joisha samuel p. midkiff mauricio j. serrano manish gupta
detecting defects in object-oriented designs: using reading techniques to increase software quality  inspections can be used to identify defects in software artifacts. in this way, inspection methods help to improve software quality, especially when used early in software development. inspections of software design may be especially crucial since design defects (problems of correctness and completeness with respect to the requirements, internal consistency, or other quality attributes) can directly affect the quality of, and effort required for, the implementation.  we have created a set of "reading techniques" (so called because they help a reviewer to "read" a design artifact for the purpose of finding relevant information) that gives specific and practical guidance for identifying defects in object-oriented designs. each reading technique in the family focuses the reviewer on some aspect of the design, with the goal that an inspection team applying the entire family should achieve a high degree of coverage of the design defects.  in this paper, we present an overview of this new set of reading techniques. we discuss how some elements of these techniques are based on empirical results concerning an analogous set of reading techniques that supports defect detection in requirements documents. we present an initial empirical study that was run to assess the feasibility of these new techniques, and discuss the changes made to the latest version of the techniques based on the results of this study.  guilherme travassos forrest shull michael fredericks victor r. basili
efficient and safe-for-space closure conversion  modern compilers often implement function calls (or returns) in two steps: first, a "closure" environment is properly installed to provide access for free variables in the target program fragment; second, the control is transferred to the target by a "jump with arguments (for results)." closure conversion---which decides where and how to represent closures at runtime---is a crucial step in the compilation of functional languages. this paper presents a new algorithm that exploits the use of compile-time control and data-flow information to optimize funtion calls. by extensive closure sharing and allocation by 36% and memory fetches for local and global variables by 43%; and improves the already efficient code generated by an earlier version of the standard ml of new jersey compiler by about 17% on a decstation 5000. moreover, unlike most other approaches, our new closure-allocation scheme the strong safe-for-space- complexity rule, thus achieving good asymptotic space usage.  zhong shao andrew w. appel
building reliable, high-performance communication systems from components although building systems from components has attractions, this approach also has problems. can we be sure that a certain configuration of components is correct? can it perform as well as a monolithic system? our paper answers these questions for the ensemble communication architecture by showing how, with help of the nuprl formal system, configurations may be checked against specifications, and how optimized code can be synthesized from these configurations. the performance results show that we can substantially reduce end-to-end latency in the already optimized ensemble system. finally, we discuss whether the techniques we used are general enough for systems other than communication systems. xiaoming liu christoph kreitz robbert van renesse jason hickey mark hayden kenneth birman robert constable
the function-class  the 'function-class' concept is introduced and explained in this paper.  the 'function-class' specifies the function's input procedure, input requirement, output requirement and output procedure. it includes the argument evaluation process in its input procedure part, and the output value type in its output requirement part. but it has other components which can describe the function's behavior in more detail.  the 'function-class' can be represented in a declarative form, i.e. in a calculus form using *, +, and operators. the function can also be defined in a declarative form. this format increases the readability of the program.  the feasibility of the 'function class' is considered in the context of its implementation in lisp- like environments.  the 'function-class' idea is not restricted to lisp language, although it has been originally developed in the lisp-1.9 context. there are several utilizations including program checking and optimized compilation.  toshiaki kurokawa
a validation of software metrics using many metrics and two resources  in this paper are presented the results of a study in which several production software systems are analyzed using ten software metrics. the ten metrics include both measures of code details, measures of structure, and combinations of these two. historical data recording the number of errors and the coding time of each component are used as objective measures of resource expenditure of each component. the metrics are validated by showing: (1) the metrics singly and in combination are useful indicators of those components which require the most resources, (2) clear patterns between the metrics and the resources expended are visible when both resources are accounted for, (3) measures of structure are as valuable in examining software systems as measures of code details, and (4) the choice of which, or how many, software metrics to employ in practice is suggested by measures of "yield" and "coverage".  dennis kafura james canning
object-oriented logical specification of time-critical systems  we define trio+, an object-oriented logical language for modular system specification. trio+ is based on trio, a first-order temporal language that is well suited to the specification of embedded and real-time systems, and that provides an effective support to a variety of validation activities, like specification testing, simulation, and property proof. unfortunately, trio lacks the ability to construct specifications of complex systems in a systematic and modular way. trio+ combines the use of constructs for hierarchical system decomposition and object-oriented concepts like inheritance and genericity with an expressive and intuitive graphic notation, yielding a specification language that is formal and rigorous, yet still flexible, readable, general, and easily adaptable to the user's needs. after introducing and motivating the main features of the language, we illustrate its application to a nontrivial case study extracted from a real-life industrial application.  angelo morzenti pierluigi san pietro
an operating system for real-time ada  many applications of ada are being designed for multiple program environments, distributed among one or more loosely- or tightly-coupled embedded processors, with hard real-time requirements for interrupt responsiveness to real-world i/o devices. a special-purpose operating system has been designed and implemented to support multiple communicating ada and foreign language programs on multiple embedded processors. in this operating system, the ada task is the basic unit of process concurrency, and the inter-task, inter- program and inter-processor communication functions are provided not only by ada rendezvous, but also by packages whose bodies are directly integrated with the ada tasking scheduler. the operating system also provides the capability of servicing hardware interrupts in ada with very low latency and high throughput.  h. rabbie d. nelson-gal
the duality of memory and communication in the implementation of a multiprocessor operating system  mach is a multiprocessor operating system being implemented at carnegie-mellon university. an important component of the mach design is the use of memory objects which can be managed either by the kernel or by user programs through a message interface. this feature allows applications such as transaction management systems to participate in decisions regarding secondary storage management and page replacement.  this paper explores the goals, design and implementation of mach and its external memory management facility. the relationship between memory and communication in mach is examined as it relates to overall performance, applicability of mach to new multiprocessor architectures, and the structure of application programs.  m. young a. tevanian r. rashid d. golub j. eppinger
systems analysis: the challenge of integrating two competing technologies  as object oriented technologies continue to permeate industrial software development methodologies, it is imperative that the techniques used in these methodologies are re-evaluated. classic top down structured analysis and design techniques are competing against object oriented techniques within these methodologies. this paper compares and contrasts both of these paradigms drawing conclusions about their strengths and weaknesses and suggesting that the two paradigms within systems analysis may actually provide similar information.  paula gabbert
dejavu: deterministic java replay debugger for jalapeño java virtual machine  the execution behavior of a java application can be non-deterministic due to multithreading. this non-determinism makes understanding and debugging multithreaded java applications a difficult and laborious process. dejavu (deterministic java replay utility) helps the user in understanding and debugging non-deterministic java applications by deterministically replaying the execution behavior of a non-deterministic execution. in this demo, we will present a debugger for the jalapeño java virtual machine that utilizes the replay capability provided by dejavu. the debugger helps in isolating non- deterministic failure(s) by faithfully reproducing the same execution behavior that led to the observe failure(s). jalapeno is a jvm being developed at ibm t. j. watson research center. the debugger provides the following features: (1) dejavu deterministically replays java programs; (2) remote reflection supports general debugging functionalities such as setting breakpoints, examining the program state, and detecting deadlocks; and (3) a gui provides an intuitive and easy to use interface.  bowen alpern ton ngo jong-deok choi manu sridharan
clos: integrating object-oriented and functional programming  lisp has a long history as a functional language,* where action is invoked by calling a procedure, and where procedural abstraction and encapsulation provide convenient modularity boundaries. a number of attempts have been made to graft object-oriented programming into this framework without losing the essential character of lisp---to include the benefits of data abstraction, extensible type classification, incremental operator definition, and code reuse through an inheritance hierarchy.  the common lisp object system (clos) [3], a result of the ansi standardization process for common lisp, represents a marriage of these two traditions. this article explores the landscape in which the major object-oriented facilities exist, showing how the clos solution is effective within the two contexts.  richard p. gabriel jon l. white daniel g. bobrow