Towards an automatic complexity analysis for generic programs

Since the Standard Template Library (STL), generic libraries in C++ rely on concepts to precisely specify the requirements of generic algorithms (function templates) on their parameters (template arguments). Modifying the definition of a concept even slightly, can have a potentially large impact on the (interfaces of the) entire library. In particular the non-local effects of a change, however, make its impact difficult to determine by hand. In this paper we propose a conceptual change impact analysis (CCIA), which determines the impact of changes of the conceptual specification of a generic library. The analysis is organized in a pipe-and-filter manner, where the first stage finds any kind of impact, the second stage various specific kinds of impact. Both stages describe reachability algorithms, which operate on a conceptual dependence graph. In a case study, we apply CCIA to a new proposal for STL iterator concepts, which is under review by the C++ standardization committee. The analysis shows a number of unexpected incompatibilities and, for certain STL algorithms, a loss of genericity.

A complete traversal of a container C (such as a set) is informally described by the iteration scheme for x in C F(x,C) where F is a function that might possibly modify C by inserting new elements into it. We assume that the order in which the elements are treated is not relevant, as long as the iteration continues until F has been applied to all elements currently in C, including those F has inserted. Standard iteration mechanisms, such as the iterators provided in the C++ Standard Template Library (STL), do not directly support complete traversals. In this paper we present two approaches to complete traversals, both extending the STL framework, one by means of generic algorithms and the other by means of a container adaptor.

In my last column (see ibid., January/February 2001), I talked about a notational device for matrix algebra called tensor diagrams. This time I write some C++ code to symbolically evaluate these quantities. This gives me a chance to play with some as yet untried features in the C++ standard library, such as strings and standard template library (STL) container classes.

Traditional static checking centers around finding bugs in programs by isolating cases where the language has been used incorrectly. These language‐based checkers do not understand the semantics of software libraries, and therefore cannot be used to detect errors in the use of libraries. In this paper, we introduce STLlint, a program analysis we have implemented for the C++ Standard Template Library and similar, generic software libraries, and we present the general approach that underlies STLlint. We show that static checking of library semantics differs greatly from checking of language semantics, requiring new representations of program behavior and new algorithms. Major challenges include checking the use of generic algorithms, loop analysis for interfaces, and organizing behavioral specifications for extensibility. Copyright © 2005 John Wiley & Sons, Ltd.

This paper demonstrates a unified and garbage-collector independent way to describe the information required for precise collection. Thereby it is possible to construct, a library that can be used with various garbage collectors, without modifying the code of the library or the collector itself. The library design presented applies the adaptor idiom of generic programming which guarantees no overhead incurred if the library is used with manual allocators or with garbage collectors that do not require programmer cooperation. As an illustration of our approach we provide sample adaptors for Bartlett's and CMM primary collectors. We also show that the Standard Template Library (STL) can be easily modified to become garbage-collector aware.

This paper demonstrates a unified and garbage-collector independent way to describe the information required for precise collection. Thereby it is possible to construct, a library that can be used with various garbage collectors, without modifying the code of the library or the collector itself. The library design presented applies the adaptor idiom of generic programming which guarantees no overhead incurred if the library is used with manual allocators or with garbage collectors that do not require programmer cooperation. As an illustration of our approach we provide sample adaptors for Bartlett's and CMM primary collectors. We also show that the Standard Template Library (STL) can be easily modified to become garbage-collector aware.

Standard iteration mechanisms, even ones of such generality as those in the C++ Standard Template Library (STL), do not allow insertions to be made in a container during a traversal of the container. Since ad hoc ways of handling such iterations are tedious to program and error-prone, programmers should ideally have at their command an efficient generic solution. In earlier work we formally characterized the complete traversal problem and presented generic solutions by means of two generic algorithms and a container adaptor, all defined within the STL framework. Here we develop additional theory for reasoning about complete traversals and address the question of how general the complete traversal problem is by showing that it subsumes well-known graph (or relation) problems such as reachability and transitive closure.

This tutorial gives an overview of the C++ standard template library (STL), including its overall structure, functionality, and capabilities. Particular emphasis is placed on the ways in which STL ...

A functional style of programming has become common in C++, following the introduction of the Standard Template Library (STL) into C++'s standard library. C++ is, however, notably lacking in its support for this style and thus cannot take full advantage of its own standard libraries. C++'s mechanisms for defining functions or objects to pass to STL algorithms are overly verbose. The effective use of modern C++ libraries calls for lambda functions in the language.This paper describes a design and implementation of built-in lambda functions for C++. C++'s compilation model, where activation records are maintained in a stack, and the lack of automatic object lifetime management, make safe lambda functions and closures challenging: if a closure outlives its scope of definition, references stored in a closure dangle. Our design is careful to balance between conciseness of syntax and explicit annotations to guarantee safety.Lambda functions can be declared without annotating their parameter types. C++0x, the forthcoming revision of standard C++, supports constrained templates and modular type checking. We describe how to infer parameter types of lambda functions from the constraints of generic functions in order to support modular type checking in the presence of lambda functions. Our design is currently under consideration for adoption to C++0x.

An architecture for generic extensions

This paper describes a suite of laboratory experiments for a CS2 course. The main thrust of the experiments is to promote an understanding of a container-class library: the Standard Template Library for C++ or the Java Generic Library for Java. All of the experiments are stored on the World Wide Web, and students have considerable latitude on when each experiment must be completed.

This paper describes a suite of laboratory experiments for a CS2 course. The main thrust of the experiments is to promote an understanding of a container-class library: the Standard Template Library for C++ or the Java Generic Library for Java. All of the experiments are stored on the World Wide Web, and students have considerable latitude on when each experiment must be completed.

A short example of a Windows® application is modified to use the generic containers, iterators, and function adapters of the C++ Standard Template Library. Comparison is made with the containers and iteration mechanism provided by the Microsoft Foundation Classes.

This paper proposes extensions to the OpenMP standard toprovide first-class support for parallelizing generic libraries such as theC++ Standard Library (SL). Generic libraries are especially known fortheir efficiency, reusability and composibility. As such, with the adventof ubiquitous parallelism, generic libraries offer an excellent avenue forparallelizing the existing applications that use these libraries withoutrequiring the applications to be rewritten. OpenMP, which would beideal for executing such parallelizations, does not support many of themodern C++ idioms such as iterators and function objects that are usedextensively in generic libraries. Accordingly, we propose extensions toOpenMP to better support modern C++ idioms to aid in the parallelizationof generic libraries and applications built with those libraries.

In the west inland of China, construction of large-span bridges become more and used, but in the existing anti-wind specification there is not the explicit values of strong wind characteristic parameters for inland areas influenced by complex mountainous region. Considering the phenomenon that the study on field measurement of turbulence characteristics has not yet been developed and combining the cable-stayed bridge with span 352m in the western gap of valley areas, a data processing system of wind speed observation based on Borland C++ Builder is compiled. The system can quickly and intelligently realize the statistical analysis of wind field monitoring data by the integration with standard template library (STL) which is defined as vector in C++. The paper presents program function, structure and development thoughts. Through the analysis for one-year field measured data, strong wind characteristics such as, the mean wind velocity, direction, turbulence intensity, gust factor and turbulence integral length are obtained. The results of the analysis provide the bases for wind tunnel test, flutter and buffeting analysis and wind load calculation and the results are compared with those of numerical simulation by FLUENT. The reliability and efficiency are confirmed.