Dynamic coupling measurement for object-oriented software

The relationships between coupling and external quality factors of object-oriented software have been studied extensively for the past few years. For example, several studies have identified clear empirical relationships between class-level coupling and class fault-proneness. A common way to define and measure coupling is through structural properties and static code analysis. However, because of polymorphism, dynamic binding, and the common presence of unused ("dead") code in commercial software, the resulting coupling measures are imprecise as they do not perfectly reflect the actual coupling taking place among classes at runtime. For example, when using static analysis to measure coupling, it is difficult and sometimes impossible to determine what actual methods can be invoked from a client class if those methods are overridden in the subclasses of the server classes. Coupling measurement has traditionally been performed using static code analysis, because most of the existing work was done on nonobject oriented code and because dynamic code analysis is more expensive and complex to perform. For modern software systems, however, this focus on static analysis can be problematic because although dynamic binding existed before the advent of object-orientation, its usage has increased significantly in the last decade. We describe how coupling can be defined and precisely measured based on dynamic analysis of systems. We refer to this type of coupling as dynamic coupling. An empirical evaluation of the proposed dynamic coupling measures is reported in which we study the relationship of these measures with the change proneness of classes. Data from maintenance releases of a large Java system are used for this purpose. Preliminary results suggest that some dynamic coupling measures are significant indicators of change proneness and that they complement existing coupling measures based on static analysis.     

Regression test selection for C++ software

Regression testing is an important but expensive software maintenance activity performed with the aim of providing confidence in modified software. Regression test selection techniques reduce the cost of regression testing by selecting test cases for a modified program from a previously existing test suite. Many researchers have addressed the regression test selection problem for procedural language software, but few have addressed the problem for object‐oriented software. This paper presents a regression test selection technique for use with object‐oriented software. The technique constructs graph representations for software, and uses these graphs to select test cases, from the original test suite, that execute code that has been changed for the new version of the software. The technique is strictly code based, and requires no assumptions about the approach used to specify or test the software initially. The technique applies to modified and derived classes, and to application programs that use modified classes. Copyright © 2000 John Wiley & Sons, Ltd.     

Measuring complexity in C++ application software

This paper concerns the use of design/source-code complexity metrics in analysing C++ software. It describes the use of one suite of object-oriented metrics published by Chidamber and Kemerer¹ to evaluate a commercial C++ application. It provides an interpretation and critique of these metrics, including the use of two traditional metrics (Cyclomatic Complexity² and Software Science³) in association with these object-oriented metrics. The evolution, over a two and a half year period, of one commercial grade C++ application comprising 114 classes with 25,000 lines of code is studied. The efforts consumed in bug fixes and enhancements are correlated with the complexity measures on a per class basis, and results are presented. These results are compared to those from other workers. The paper provides a detailed analysis of the practical strengths and weaknesses of the metrics suite in the light of experiences with its use. © 1998 John Wiley & Sons, Ltd.     

A metaprogrammed C++ framework for hardware/software component integration and communication

With the ever growing complexity of System-on-Chip design, a considerable effort has been made to introduce higher levels of abstraction and to integrate high-level synthesis solutions to the design flow. In such design flows, a uniform communication interface is needed to enable high-level implementations of SoC components regardless of whether they are compiled as software running on a processor or synthesized to dedicated hardware IPs. This paper addresses this issue and proposes a component communication framework that defines an object-oriented remote call mechanism which allows transparent communication across hardware/software boundaries. The proposed framework relies on C++ static metaprogramming techniques to efficiently abstract communication between components implemented using high-level C++. We also define a portability layer that enables the migration of designs throughout different hardware platforms, operating systems, and tools. We assessed the performance and area footprint of our communication infrastructure through the implementation of a voice processing pipeline on top of a Network-on-Chip based architecture. Our results, when compared to previous related works with the same set of capabilities, show that our mechanisms yield small overhead in terms of software memory (up to 64% smaller), FPGA resources (up to 40% smaller), and hardware/software communication latency (up to 51% smaller).     

基于C++及其扩展语言的动态剖析

程序优化是提高程序运行效率的重要步骤,程序剖析是程序优化的第一步。对于串行语言,程序剖析代码是由编译器通过一个命令行开关自动插入。但是,大部分并行语言编译器都不具有这个功能。该文以并行C++语言的可移植的动态剖析程序(profiler)为例,从两方面对问题进行了论述:首先给出实现可移植动态剖析程序的一般方法;然后分析一个用于pC++插桩(Instrumentation)工具。     

用Visual C++开发工业控制软件的实时性研究

通过具体的测试数据对用Visual C 开发工业控制软件的实时性问题进行了分析研究, 并提出了实用的解决办法。     

Developing Web services for C and C++

gSOAP is a platform-independent development environment for deploying efficient SOAP/XML Web services in C and C++.We implemented the traditional remote procedure calling (RPC stub-skeleton design for gSOAP, producing the RPC stub and skeleton routines for Web service applications at compile time. The RPC stub and skeleton routines are precompiled, which speeds encoding and decoding at runtime. The skeleton routines expose a C and C++ application as a Web service on the Internet and are responsible for binding SOAP/XML request and response messages to the application at runtime.     

Functional Programming Library for C++

Programming and Computer Software - Modern functional programming languages, such as Haskell, Scala, ML, and F#, have properties that make it possible to implement logically complicated algorithms...     

Contract-checking wrappers for C++ classes

Two kinds of interface contract violations can occur in component-based software: A client component can fail to satisfy a requirement of a component it is using, or a component implementation can fail to fulfill its obligations to the client. The traditional approach to detecting and reporting such violations is to embed assertion checks into component source code, with compile-time control over whether they are enabled. This works well for the original component developers, but it fails to meet the needs of component clients who do not have access to source code for such components. A wrapper-based approach, in which contract checking is not hard-coded into the underlying component but is "layered" on top of it, offers several relative advantages. It is practical and effective for C++ classes. Checking code can be distributed in binary form along with the underlying component, it can be installed or removed without requiring recompilation of either the underlying component or the client code, it can be selectively enabled or disabled by the component client on a per-component basis, and it does not require the client to have access to any special tools (which might have been used by the component developer) to support wrapper installation and control. Experimental evidence indicates that wrappers in C++ impose-modest additional overhead compared to inlining assertion checks.     

C++程序设计案例遴选

针对C++程序设计课程中缺乏经典项目案例的问题,分析了从IT公司、开源项目中选取C++开发案例的优缺点。从开源项目中选取了8个关注度高、适合大学低年级学生知识结构的案例,设计了一套定量化的评估指标,使用代码查询语言(Code Query Language,CQL)及代码分析工具CppDepend,对这些案例进行了定量评估,给出了遴选C++程序设计案例的建议。     

A software metric system for module coupling

Low module coupling is considered to be a desirable quality for modular programs to have. Previously, coupling has been defined subjectively and not quantified, making it difficult to use in practice. In this article, we extend previous work to reflect newer programming languages and quantify coupling by developing a general software metric system that allows us to automatically measure coupling. We have precisely defined the levels of coupling so that they can be determined algorithmically, incorporated the notion of direction into the coupling levels, and accounted for different types of nonlocal variables present in modern programming languages. With our system, we can measure the coupling between all pairs of modules in a system, measure the coupling of a particular module with all other modules in a system, and measure the coupling of an entire system. We have implemented our metric system so that it measures the coupling between pairs of procedures in arbitrary C programs and have analyzed several well-used systems of various sizes.     

Multiple-parameter coupling metrics for layered component-based software

Coupling represents the degree of interdependence between two software components. Understanding software dependency is directly related to improving software understandability, maintainability, and reusability. In this paper, we analyze the difference between component coupling and component dependency, introduce a two-parameter component coupling metric and a three-parameter component dependency metric. An important parameter in both these metrics is coupling distance, which represents the relevance of two coupled components. These metrics are applicable to layered component-based software. These metrics can be used to represent the dependencies induced by all types of software coupling. We show how to determine coupling and dependency of all scales of software components using these metrics. These metrics are then applied to Apache HTTP, an open-source web server. The study shows that coupling distance is related to the number of modifications of a component, which is an important indicator of component fault rate, stability and subsequently, component complexity.

Computational wave optics library for C++: CWO++ library

Diffraction calculations, such as the angular spectrum method and Fresnel diffractions, are used for calculating scalar light propagation. The calculations are used in wide-ranging optics fields: for example, Computer Generated Holograms (CGHs), digital holography, diffractive optical elements, microscopy, image encryption and decryption, three-dimensional analysis for optical devices and so on. However, increasing demands made by large-scale diffraction calculations have rendered the computational power of recent computers insufficient. We have already developed a numerical library for diffraction calculations using a Graphic Processing Unit (GPU), which was named the GWO library. However, this GWO library is not user-friendly, since it is based on C language and was also run only on a GPU. In this paper, we develop a new C++ class library for diffraction and CGH calculations, which is referred to as a CWO++ library, running on a CPU and GPU. We also describe the structure, performance, and usage examples of the CWO++ library.Program summaryProgram title: CWO++Catalogue identifier: AELL_v1_0Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AELL_v1_0.htmlProgram obtainable from: CPC Program Library, Queen?s University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 109 809No. of bytes in distributed program, including test data, etc.: 4 181 911Distribution format: tar.gzProgramming language: C++Computer: General computers and general computers with NVIDIA GPUsOperating system: Windows XP, Vista, 7Has the code been vectorized or parallelized?: Yes. 1 core processor used in CPU and many cores in GPU.RAM: 256 M bytesClassification: 18External routines: CImg, FFTWNature of problem: The CWO++ library provides diffraction calculations which are useful for Computer Generated Holograms (CGHs), digital holography, diffractive optical elements, microscopy, image encryption and decryption and three-dimensional analysis for optical devices.Solution method: FFT-based diffraction calculations, computer generated holograms by direct integration.Running time: The sample runs provided take approximately 5 minutes for the C++ version and 5 seconds for the C++ with GPUs version.     

LOCAL++: A C++ framework for local search algorithms

Local search is an emerging paradigm for combinatorial search which has recently been shown to be very effective for a large number of combinatorial problems. It is based on the idea of navigating the search space by iteratively stepping from one solution to one of its neighbors, which are obtained by applying a simple local change to it. In this paper we present LOCAL++, an object‐oriented framework to be used as a general tool for the development and implementation of local search algorithms in C++. The framework comprises a hierarchy of abstract template classes, one for each local search technique taken into account (i.e. hill‐climbing, simulated annealing and tabu search). Each class specifies and implements the invariant part of the algorithm built according to the technique, and is supposed to be specialized by a concrete class once a given search problem is considered, so as to implement the problem‐dependent part of the algorithm. LOCAL++ comprises also a set of abstract classes for creating new techniques by combining different search techniques and different neighborhood relations. The architecture of LOCAL++ provides a principled modularization for the solution of combinatorial search problems, and helps the designer deriving a neat conceptual scheme of the application, thus facilitating the development and debugging phases. LOCAL++ proved to be flexible enough for the implementation of the algorithms solving various scheduling problems. Copyright © 2000 John Wiley & Sons, Ltd.     

Parc++: A parallel C++

PARC++ is a system that supports object-oriented parallel programming in C++. PARC++ provides the user with a set of predefined C++ classes that can easily be used for the construction of parallel C++ programs. With the help of PARC++ objects, the programmer is able to create and start new processes (threads), to synchronize their activities (Blocklock, Monitor) and to manage communication via message passing (Mailbox). PARC++ is written in C++ and currently runs on top of the EMEX operating system on a FORCE machine with 11 processing elements and an EDS (European Declarative System) with 28 processing elements. The paper also contains information about the run-time system model, the implementation and some performance measurements.     

CRunDec: A C++ package for running and decoupling of the strong coupling and quark masses

In this paper we present the C++ package CRunDec which implements all relevant formulae needed for the running and decoupling for the strong coupling constant and light quark masses. Furthermore, several formulae are implemented which can be used to transform the heavy quark masses among different renormalization schemes. CRunDec is the C++ version on the Mathematica package RunDec containing several updates and improvements.     

An investigation of coupling,reuse and maintenance in a commercial C++ application

This paper describes an investigation into the use of coupling complexity metrics to obtain early indications of various properties of a system of C++ classes. The properties of interest are: (i) the potential reusability of a class and (ii) the likelihood that a class will be affected by maintenance changes made to the overall system. The study indicates that coupling metrics can provide useful indications of both reusable classes and of classes that may have a significant influence on the effort expended during system maintenance and testing.     

A replicated and refined empirical study of the use of friends in C++ software

The friend mechanism is widely used in C++ software even though the potential benefits of its use are disputed and little is known about when, where and why it is employed in practice. Furthermore, there is limited empirical analysis of its impact in object-oriented software, with only one study (Counsell and Newson, 2000) reported at journal level.This paper aims to add to the empirical evidence of friendship’s impact by replicating Counsell and Newson (2000)’s original study. The study’s design is refined to improve the construct validity of the evaluation and a larger cohort of systems is used to improve the generalisability of the results. The findings suggest that classes involved in friendship are coupling hotspots and that there is no link between inheritance and friendship, contrary to the findings presented in Counsell and Newson (2000). The findings also suggest that the use of friends in a class is independent of the number of hidden members in a class.     

具有并发类库的C++

本文探讨如何通过类库将并发性引入顺序面向对象语言.以C++为例,在并发类库中提供并发类及相应工具,使之支持分布并行的面向对象程序设计.本文介绍并发类库及语言底层支撑系统的设计与实现,最后给出初步测试结果.     

Para++: A High Level C++ Interface for Message Passing

This paper describes a high level C++ interface for message passing applications. Our interface is built on top of PVM and MPI. The two main contributions are to allow a quicker design of parallel applications without any important drop of performances. We introduce two levels of tasks and use C++ streams for communications. We also present a performance study over both PVM and MPI to show the overhead of our implementation. Finally, we detail two applications based on the heat equation to explain howPara++ can be used for SPMD and MPMD applications.