The evaluation of software systems' structure using quantitative software metrics

The design and analysis of the structure of software systems has typically been based on purely qualitative grounds. In this paper we report on our positive experience with a set of quantitative measures of software structure. These metrics, based on the number of possible paths of information flow through a given component, were used to evaluate the design and implementation of a software system (the UNIX operating system kernel) which exhibits the interconnectivity of components typical of large-scale software systems. Several examples are presented which show the power of this technique in locating a variety of both design and implementation defects. Suggested repairs, which agree with the commonly accepted principles of structured design and programming, are presented. The effect of these alterations on the structure of the system and the quantitative measurements of that structure lead to a convincing validation of the utility of information flow metrics.     

Concurrent and distributed garbage collection of active objects

This paper shows how to perform concurrent and distributed automatic garbage collection of objects possessing their own thread of control. The relevance of garbage collection and active objects to distributed applications is briefly discussed and the specific model of active objects used in the paper is explained. The collector is comprised of independent local collectors, one per node, and a distributed global collector. The mutator (application), the local collectors and the global collector run concurrently. An important part of this paper is the detailed presentation of the algorithms necessary to achieve correct concurrent operation among the collectors and between the collectors and the mutator. The collector builds on previous algorithms for taking snapshots in distributed systems and for detecting termination     

Software quality metrics based on interconnectivity

We state a set of criteria that has guided the development of a metric system for measuring the quality of a largescale software product. This metric system uses the flow of information within the system as an index of system interconnectivity. Based on this observed interconnectivity, a variety of software metrics can be defined. The types of software quality features that can be measured by this approach are summarized. The data-flow analysis techniques used to establish the paths of information flow are explained and illustrated. Finally, a means of integrating various metrics and models into a comprehensive software development environment is discussed. This possible integration is explained in terms of the Gandalf system currently under development at Carnegie-Mellon University.     

Working set measurements based on sampled reference string information

The development of new memory technologies combined with the pressures for ever larger, database software systems will continue to make a multi-level memory an attractive and cost-effective system organization. The performance of a process executing in a system with such a memory hierarchy depends on both the memory referencing behavior of the process and the policy used to control the contents of each memory level. The direct observation of this referencing behavior by capturing every memory reference involves a substantial overhead and can not be applied to ‘time-critical’ systems because the measurement radically perturbs the normal operation of the system. This paper reports on the development and testing of a technique which determines the structural characteristics of a process's memory referencing behavior based only on a sampling of the complete reference string. This method controls the cost of the measurement by adjusting the sampling rate while simultaneously attempting to accurately determine the referencing behavior as reflected in its working set measurements. The results presented in this paper are based on the use of a set of successively more realistic synthetic behavior models as well as on actual reference strings.     

Strategy independent program restructuring using the critical reference principle

This paper defines and analyzes two new strategy independent program restructuring algorithms. The more effective of these two algorithms combines the critical reference principle used in strategy dependent algorithms with the bounded locality interval mechanism. Limited, though encouraging, results are presented which show that this new algorithm can be at least as effective as the Critical LRU algorithm, even when the memory management policy is LRU itself, and can also be at least as effective as Critical Working Set, even when the memory management policy is the working set policy. This new algorithm combines the benefits of strategy independent restructuring with the performance improvements previously possible only with a strategy dependent method.     

The PRIMA Grid Authorization System

PRIMA, a system for PRIvilege Management and Authorization, provides enhanced Grid security services. The requirements for these services are derived from usage scenarios and supported by a survey of Grid users. The requirements for added flexibility, increased expressiveness, and more precise enforcement are met by a combination of three mechanisms: (1) use of secure, fine-grained privileges representing externalized access rights for Grid resources that can be freely created, shared, and employed by Grid users; (2) a dynamic policy generated for each request combining the requests user-provided privileges with the resources access control policy; and (3) dynamic execution environments specially provisioned for each request that are enforced by the resources native operating system and which support legacy applications. PRIMA has been implemented as an extension of the Globus Toolkit Grid middleware.     

Improving software maintenance at Martin Marietta

Using data collected throughout a major project, the authors apply common statistical methods to quantitatively assess and evaluate improvements in a large contractor's software-maintenance process. Results show where improvements are needed; examining the change in statistical results lets you quantitatively evaluate the effectiveness of the improvements. We selected a process-assessment methodology developed by J.E. Henry (1993) that follows Total Quality Management principles and is based on Watts Humphrey's Process Maturity Framework. It lets you use a process modeling technique based on control-flow diagrams to define an organization's maintenance process. After collecting process and product data throughout the maintenance process, you analyze it using parametric and nonparametric statistical techniques. The statistical-analysis results and the process model help you assess and guide improvements in the organization's maintenance process. The method uses common statistical tests to quantify relationships among maintenance activities and process and product characteristics. The relationships, in turn, tell you more about the maintenance process and how requirements changes affect the product