scholarly journals Static Analysis of Run-Time Errors in Embedded Real-Time Parallel C Programs

Author(s):  
Antoine Miné
10.29007/g3fd ◽  
2018 ◽  
Author(s):  
Daniel Kroening ◽  
Natasha Sharygina ◽  
Stefano Tonetta ◽  
Aliaksei Tsitovich ◽  
Christoph M. Wintersteiger

Loopfrog is a scalable static analyzer for ANSI-C programs, that combines the precision of model checking and the performance of abstract interpretation. In contrast to traditional static analyzers, it does not calculate the abstract fix-point of a program by iterative application of an abstract transformer. Instead, it calculates symbolic abstract transformers for program fragments (e.g., loops) using a loop summarization algorithm. Loopfrog computes abstract transformers starting from the inner-most loops, which results in linear (in the number of the looping constructs) run-time of the sum- marization procedure and which is often considerably smaller than the traditional saturation procedure of abstract interpetation. It also provides “leaping” counterexamples to aid in the diagnosis of errors.


Water ◽  
2020 ◽  
Vol 12 (3) ◽  
pp. 695 ◽  
Author(s):  
Weiwei Bi ◽  
Yihui Xu ◽  
Hongyu Wang

Over the past few decades, various evolutionary algorithms (EAs) have been applied to the optimization design of water distribution systems (WDSs). An important research area is to compare the performance of these EAs, thereby offering guidance for the selection of the appropriate EAs for practical implementations. Such comparisons are mainly based on the final solution statistics and, hence, are unable to provide knowledge on how different EAs reach the final optimal solutions and why different EAs performed differently in identifying optimal solutions. To this end, this paper aims to compare the real-time searching behaviour of three widely used EAs, which are genetic algorithms (GAs), the differential evolution (DE) algorithm and the ant colony optimization (ACO). These three EAs are applied to five WDS benchmarking case studies with different scales and complexities, and a set of five metrics are used to measure their run-time searching quality and convergence properties. Results show that the run-time metrics can effectively reveal the underlying searching mechanisms associated with each EA, which significantly goes beyond the knowledge from the traditional end-of-run solution statistics. It is observed that the DE is able to identify better solutions if moderate and large computational budgets are allowed due to its great ability in maintaining the balance between the exploration and exploitation. However, if the computational resources are rather limited or the decision has to be made in a very short time (e.g., real-time WDS operation), the GA can be a good choice as it can always identify better solutions than the DE and ACO at the early searching stages. Based on the results, the ACO performs the worst for the five case study considered. The outcome of this study is the offer of guidance for the algorithm selection based on the available computation resources, as well as knowledge into the EA’s underlying searching behaviours.


Author(s):  
Soochan Hwang ◽  
Sang-Young Cho ◽  
Taehyung Wang ◽  
Phillip C.-Y. Sheu

This paper describes a 3-D visualization method based on the concept of characteristic views (CVs). The idea of characteristic views was derived based on the observation that the infinite possible views of a 3-D object can be grouped into a finite number of equivalence classes so that within each class all the views are isomorphic in the sense that they have the same line-junction graphs. To visualize the changes of scenes in real time, the BSP tree algorithm is known to be efficient in a static environment in which the viewpoint can be changed easily. However, if a scene consists of many objects and each object consists of many polygons, the time complexity involved in traversing a BSP tree increases rapidly so that the original BSP tree algorithm may not be efficient. The method proposed in this paper is object-oriented in the sense that, for all viewpoints, at the preprocessing stage the ordering for displaying the objects is determined. At run time, the objects are displayed based on a pre-calculated ordering according to the viewpoint. In addition, a CV is used as a basic 2-D projected image of a 3-D object.


Author(s):  
Subburaj Ramasamy ◽  
Anuj Singh ◽  
Deepak Singal
Keyword(s):  

10.29007/7lrd ◽  
2018 ◽  
Author(s):  
Ian Cassar ◽  
Adrian Francalanza ◽  
Duncan Attard ◽  
Luca Aceto ◽  
Anna Ingolfsdottir

Ensuring formal correctness for actor-based, concurrent systems is a difficult task, pri- marily because exhaustive, static analysis verification techniques such as model checking quickly run into state-explosion problems. Runtime monitoring techniques such as Run- time Verification and Adaptation circumvent this limitation by verifying the correctness of a program by dynamically analysing its executions. This paper gives an overview of a suite of monitoring tools available for verifying and adapting actor-based Erlang programs.


2020 ◽  
Author(s):  
Kristóf Umann ◽  
Zoltán Porkoláb

Uninitialized variables have been a source of errors since the beginning of software engineering. Some programming languages (e.g. Java and Python) will automatically zero-initialize such variables, but others, like C and C++, leave their state undefined. While laying aside initialization in C and C++ might be a performance advantage if an initial value can't be supplied, working with such variables is an undefined behavior, and is a common source of instabilities and crashes. To avoid such errors, whenever meaningful initialization is possible, it should be used. Tools for detecting these errors run time have existed for decades, but those require the problematic code to be executed. Since in many cases the number of possible execution paths are combinatoric, static analysis techniques emerged as an alternative. In this paper, we overview the technique for detecting uninitialized C++ variables using the Clang Static Analyzer, and describe various heuristics to guess whether a specific variable was left in an undefined state intentionally. We implemented a prototype tool based on our idea and successfully tested it on large open source projects.


2017 ◽  
Vol 43 (4) ◽  
pp. 268-276 ◽  
Author(s):  
V. K. Koshelev ◽  
V. N. Ignatiev ◽  
A. I. Borzilov ◽  
A. A. Belevantsev

Sign in / Sign up

Export Citation Format

Share Document