Loek G. Cleophas

Performance of C++ bit-vector implementations

This paper describes an experimental study to compare the performance of various dynamically resizable bit-vector implementations for the C++ programming language. We compare the std::vector<bool> from the Standard Template Library (STL), boost::dynamic_bitset from Boost, Qt::QBitArray from QT Software, and BitMagics bm::bvector<> with one another. We also compare std::vector<char> from the STL with these because it is a dynamically resizable vector implementation that has been suggested to be an acceptable alternative for std::vector<bool>. We describe the test data and the methods that were applied to measure memory use and processing time. This lays a foundation for comparing other parts of the different C++ libraries. The results are presented and discussed in terms of the differences in the implementations of these data structures. Although the results reported in this article is specific to the mentioned C++ libraries, the techniques used to measure and compare the performance of the different libraries go beyond C++ bit-vectors and may be used more generally.

FIRE station: an environment for manipulating finite automata and regular expression views

We discuss a new tool, FIRE Station, for the visualization, exploration and manipulation of regular languages and their various representations, including regular expressions and finite state automata.

VPDSL: A DSL for Software in the Loop Simulations Covering Material Flow

We present an approach to model hardware configurations of complex manufacturing systems such as ASMLs lithography machines. These hardware configurations consist of actuator and sensor elements which are controlled by system software that consists of over 35 million lines of code. To minimize the cost of testing and system integration, software simulators of hardware configurations are used-acting as virtual hardware platforms on which the real control software can be executed and tested. An important aspect in such simulation and testing is material flow (specifically wafer flow) in the machine. To support the effective and efficient realization of simulators covering material flow, we defined a domain specific language (DSL) for modelling the hardware configurations to be simulated, and used a model-driven engineering approach to generate the software components implementing the simulators. The DSL can be used to specify not only nominal (i.e. good weather) behaviour but also simulation based fault injection scenarios. The overall approach reduces the cost of early hardware-software integration and enables simulating scenarios that cannot be executed on real machines because they are difficult or hazardous to carry out.

The effect of rewriting regular expressions on their accepting automata

Traditionally, regular expressions are transformed into (deterministic) finite automata, which are then used in, for example, searching and parsing. For an introduction to automata and regular expressions, refer to [1]. For every automaton, there is an infinite number of other automata that recognizes exactly the same language, although memory usage and performance can differ. This has lead to the wide-spread use of automata minmization techniques. In the same way, for every regular expression, there exists an infinite number of equivalent regular expressions, some of which lead to smaller/faster automata. This paper compares automaton sizes constructed from 10 different regular expressions, both before and after the rewriting transformation. Rewriting is done based on a rule set directly derived from the regular expression language (i.e. Kleene Algebra) axioms; these are listed in Table 1. The first three automata tested are the Thompson NFA [2], the Position NFA [3], and the Follow e-NFA [4]. The remaining three automata are the determinized counterparts of each NFA. For these DFA, the size of the minimized DFA is provided for comparison. For a list of the regular

Towards distributed model analytics with apache spark

The growing number of models and other related artefacts in model-driven engineering has recently led to the emergence of approaches and tools for analyzing and managing them on a large scale. The framework SAMOS applies techniques inspired by information retrieval and data mining to analyze large sets of models. As the data size and analysis complexity goes up, however, further scalability is needed. In this paper we extend SAMOS to operate on Apache Spark, a popular engine for distributed Big Data processing, by partitioning the data and parallelizing the comparison and analysis phase. We present preliminary studies using a cluster infrastructure and report the results for two datasets: one with 250 Ecore metamodels where we detail the performance gain with various settings, and a larger one of 7.3k metamodels with nearly one million model elements for further demonstrating scalability.

Workshop on Advances in Knowledge Extraction and Re-engineering of Software (selected and extended papers from WAKERS 2017)

The Workshop on Advances in Knowledge Extraction and Re-engineering of Software (WAKERS) was held at the Stellenbosch Institute for Advanced Studies (STIAS) in Stellenbosch, South Africa from January 23rd until January 26th, 2017. The workshop was specifically designed to bring together researchers and practitioners from the software reengineering and knowledge extraction communities in order to foster collaboration between these research communities.

Towards Confidentiality-by-Construction

Guaranteeing that information processed in computing systems remains confidential is vital for many software applications. To this end, language-based security mechanisms enforce fine-grained access control policies for program variables to prevent secret information from leaking through unauthorized access. However, approaches for language-based security by information flow control mostly work post-hoc, classifying programs into whether they comply with information flow policies or not after the program has been constructed. Means for constructing programs that satisfy given information flow control policies are still missing. Following the correctness-by-construction approach, we propose a development method for specifying information flow policies first and constructing programs satisfying these policies subsequently. We replace functional pre- and postcondition specifications with confidentiality properties and define rules to derive new confidentiality specifications for each refining program construct. We discuss possible extensions including initial ideas for tool support. Applying correctness-by-construction techniques to confidentiality properties constitutes a first step towards security-by-construction.

X-by-Construction

After decades of progress on Correctness-by-Construction (CbC) as a scientific discipline of engineering, it is time to look further than correctness and investigate a move from CbC to XbC, i.e., considering also non-functional properties. X-by-Construction (XbC) is concerned with a step-wise refinement process from specification to code that automatically generates software (system) implementations that by construction satisfy specific non-functional properties concerning security, dependability, reliability or resource/energy consumption, to name but a few. This track brings together researchers and practitioners that are interested in CbC and the promise of XbC.

Using CSP to Develop Quality Concurrent Software

A method for developing concurrent software is advocated that centres on using CSP to specify the behaviour of the system. A small example problem is used to illustrate the method. The problem is to develop a simulation system that keeps track of and reports on the least unique bid of multiple streams of randomly generated incoming bids. The problem’s required high-level behaviour is specified in CSP, refined down to the level of interacting processes and then verified for refinement and behavioural correctness using the FDR refinement checker. Heuristics are used to map the CSP processes to a GO implementation. Interpretive reflections are offered of the lessons learned as a result of the exercise.

CSP for parallelising Brzozowski's DFA construction algorithm

CSP, a simple and elegant process algebra, is used to specify five successive parallel versions of Brzozowski’s sequential algorithm for constructing deterministic finite automata from regular expressions. Early versions were not sufficiently mature to easily map to a programming language. However, each version exposed new possibilities for refinement so that later versions could subsequently be implemented (in Go). The exercise illustrates the value of the lightweight use of process algebras for supporting abstract thinking when attempting to solve computational problems in a parallel fashion. The emphasis here is on algorithm specification and not on the implementation.