Norbert Pataki

Multicore C++ Standard Template Library with C++0x

Nowadays, one of the most important challenges in the programming is the efficient usage of multicore processors. Many new programming languages and libraries support multicore programming. C++0x, the proposal of the next standard of C++ also supports multithreading at low level.In this paper we argue for some extensions of C++ Standard Template Library based on the features of C++0x. These extensions enhance the standard library to be more powerful in the multicore realm. In this paper we deal with the functors and lambda expressions that are a major extension in the language. We present a technique to write effective pipelines. Speculative functors aim at the effective evaluation of composite functors. Algorithms are overloaded on the associativity of lambda expressions as well.

Multicore C++ Standard Template Library in a Generative Way

Nowadays, the one of the most important challenges in the programming is the efficient usage of multicore processors. Many new programming languages and libraries support multicore programming.Cilk++ is one of the most well-known languages extension of C++ providing new keywords for multicore programming.C++ Standard Template Library is efficient generic library but it does not support parallelism. It is optimized to the sequential realm, hence it can be an efficiency bottleneck when it is used in multicore environment.In this paper we argue for a multicore implementation of C++ Standard Template Library for Cilk++. We consider the implementation of containers, algorithms, and functors as well. Our implementation takes advantage of generative technologies of C++. We also measure the speedup of our implementation.

C++ metastring library and its applications

C++ template metaprogramming is an emerging direction of generative programming: with proper template definitions we can enforce the C++ compiler to execute algorithms at compilation time. Template metaprograms have become essential part of todays C++ programs of industrial size; they provide code adoptions, various optimizations, DSL embedding, etc. Besides the compilation time algorithms, template metaprogram data-structures are particularly important. From simple typelists to more advanced STL-like data types there are a variety of such constructs. Interesting enough, until recently string, as one of the most widely used data type of programming, has not been supported. Although, boost::mpl::string is an advance in this area, it still lacks the most fundamental string operations. In this paper, we analysed the possibilities of handling string objects at compilation time with a metastring library. We created a C++ template metaprogram library that provides the common string operations, like creating sub-strings, concatenation, replace, and similar. To provide real-life use-cases we implemented two applications on top of our Metastring library. One use case utilizes compilation time inspection of input in the domain of pattern matching algorithms, thus we are able to select the more optimal search method at compilation time. The other use-case implements safePrint, a type-safe version of printf - a widely investigated problem. We present both the performance improvements and extended functionality we have achieved in the applications of our Metastring library.

Generative Version of the FastFlow Multicore Library

Nowadays, one of the most important challenges in programming is the efficient usage of multicore processors. Many new programming languages and libraries support multicore programming.FastFlow is one of the most promising multicore C++ libraries. Unfortunately, a design problem occurs in the library. One of the most important methods is pure virtual function in a base class. This method supports the communication between different threads. Although, it cannot be template function because of the virtuality, hence, the threads pass and take argument as a void* pointer. The base class is not template neither. This is not typesafe approach. We make the library more efficient and safer with the help of generative technologies.

Visualization of C++ Template Metaprograms

Template metaprograms have become an essential part of todays C++ programs: with proper template definitions we can force the C++ compiler to execute algorithms at compilation time. Among the application areas of template metaprograms are the expression templates, static interface checking, code optimization with adaptation, language embedding and active libraries. Despite all of its already proven benefits and numerous successful applications there are surprisingly few tools for creating, supporting, and analyzing C++ template metaprograms. As metaprograms are executed at compilation time they are even harder to understand. In this paper we present a code visualization tool, which is utilizing Tem plight, our previously developed C++ template metaprogram debugger. Using the tool it is possible to visualize the instantiation chain of C++ templates and follow the execution of metaprograms. Various presentation layers, filtering of template instances and step-by-step replay of the instantiations are supported. Our tool can help to test, optimize, maintain C++ template metaprograms, and can enhance their acceptance in the software industry.

Source language representation of function summaries in static analysis

Static analysis is a popular method to find bugs. In context-sensitive static analysis the analyzer considers the calling context when evaluating a function call. This approach makes it possible to find bugs that span across multiple functions. In order to find those issues the analyzer engine requires information about both the calling context and the callee. Unfortunately the implementation of the callee might only be available in a separate translation unit or module. In these scenarios the analyzer either makes some assumptions about the behavior of the callee (which may be unsound) or conservatively creates a program state that marks every value that might be affected by this function call. In this case the marked value becomes unknown which implies significant loss of precision. In order to mitigate this overapproximation, a common approach is to assign a summary to some of the functions, and each time the implementation is not available, use the summary to analyze the effect of the function call. These summaries are in fact approximations of the function implementations that can be used to model some behavior of the called functions in a given context. The most proper way to represent summaries, however, remains an open question. This paper describes a method for summarising C (or C++) functions in C (or C++) itself. We evaluate the advantages and disadvantages of this approach. It is challenging to use source language representation efficiently due to the compilation model of C/C++. We propose an efficient solution. The emphasis of the paper is on using static analysis to find errors in the programs, however the same approach can be used to optimize programs or any other tasks that static analysis is capable of. Our proof of concept implementation is available in the upstream version of the Clang compiler.

Concurrent object construction in modern object-oriented programming languages

Nowadays concurrency is a key issue in modern object-oriented programming languages. Billions of objects and object graphs are created at runtime, thus parallelization of object construction may result in signi cant speed-up in applications. In this paper we present di erent scenarios where parallelization seems to be valuable. These scenarios belong to object constructions and to di erent languages. The C++ programming language uses value semantics as basis of objectorientation. Objects can be used as values and C++ o ers copy constructors automatically that copy all members of a class. This operation seems to be ideal for parallelization because independent sources need to be copied to independent targets: without locks, without synchronization problems. We present our concurrent copy construction approach. The Spring Framework is a widely-used application framework and inversion of control container for the Java platform. At application startup the context of a Spring based application must be constructed. This context consists of many rather small objects, called beans. Among them singleton non-lazy beans are created and initialized at startup sequentially which fact increases the startup time. Besides that, Spring can manage a context hierarchy or hierarchy of containers in which each child context can access beans from parent context, but not the other way around, and sibling contexts are separated and invisible for each other. These traits make the child contexts and the independent beans feasible candidates for concurrent creation and initialization.

Poster: Implementation and Evaluation of Cross Translation Unit Symbolic Execution for C Family Languages

Static analysis is a great approach to find bugs and code smells. Some of the errors span across multiple translation units. Unfortunately, it is challenging to achieve cross translation unit analysis for C family languages. In this short paper, we describe a model and an implementation for cross translation unit (CTU) symbolic execution for C. We were able to extend the scope of the analysis without modifying any of the existing checks. The analysis is implemented in the open source Clang compiler. We also measured the performance of the approach and the quality of the reports. The implementation is already accepted into mainline Clang.

Multivendor Deployment Integration for Future Mobile Networks

During the last few years, we have seen a tremendous explosion in the range of possibilities when speaking about software delivery. The web-scale IT capabilities have evolved drastically and complex web-based applications have adapted rapidly in an ever changing world where user experience is in the focus. Terms like Agile, Cloudification, microservices or DevOps are lately on the crest of the wave.

Detecting Misusages of the C++ Standard Template Library

The C++ Standard Template Library (STL) is the most well-known and widely used library that is based on the generic programming paradigm. The STL takes advantage of C++ templates, so it is an extensible, e ective but exible system. Professional C++ programs cannot miss the usage of the STL because it increases quality, maintainability, understandability and e cacy of the code. However, the usage of C++ STL does not guarantee bugfree or errorfree code. Contrarily, incorrect application of the library may introduce new types of problems. Unfortunately, there is still a large number of properties are tested neither at compilation-time nor at run-time. It is not suprising that in implementation of C++ programs so many STL-related bugs may occur. It is clearly seen that the compilation validation is not enough to exclude the misuage of STL. Our poster introduces di erent approaches for the validation of the C++ STLs usage. We take advantage of metaprogramming techniques, static analysis based on the Clang compiler infrastructure and gdb debugging tool as well.