scholarly journals A Suite of Monitoring Tools for Erlang

10.29007/7lrd ◽  
2018 ◽  
Author(s):  
Ian Cassar ◽  
Adrian Francalanza ◽  
Duncan Attard ◽  
Luca Aceto ◽  
Anna Ingolfsdottir
Keyword(s):  
Model Checking ◽  
Static Analysis ◽  
Concurrent Systems ◽  
Runtime Monitoring ◽  
State Explosion ◽  
Monitoring Techniques ◽  
Monitoring Tools ◽  
Run Time ◽  
Verification Techniques

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.

SUPPORTING FORMAL VERIFICATION OF DIMA MULTI-AGENTS MODELS: TOWARDS A FRAMEWORK BASED ON MAUDE MODEL CHECKING

2008 ◽  
Vol 18 (07) ◽  
pp. 853-875 ◽  
Author(s):  
NOURA BOUDIAF ◽  
FARID MOKHATI ◽  
MOURAD BADRI
Keyword(s):  
Model Checking ◽  
Development Process ◽  
Formal Semantics ◽  
Concurrent Systems ◽  
Model Checker ◽  
Rewriting Logic ◽  
Generic Framework ◽  
Systems Quality ◽  
Verification Techniques ◽  
Multi Agents

Model Checking based verification techniques represent an important issue in the field of concurrent systems quality assurance. The lack of formal semantics in the existing formalisms describing multi-agents models combined with multi-agents systems complexity are sources of several problems during their development process. The Maude language, based on rewriting logic, offers a rich notation supporting formal specification and implementation of concurrent systems. In addition to its modeling capacity, the Maude environment integrates a Model Checker based on Linear Temporal Logic (LTL) for distributed systems verification. In this paper, we present a formal and generic framework (DIMA-Maude) supporting formal description and verification of DIMA multi-agents models.

scholarly journals Loopfrog — loop summarization for static analysis

10.29007/g3fd ◽  
2018 ◽  
Author(s):  
Daniel Kroening ◽  
Natasha Sharygina ◽  
Stefano Tonetta ◽  
Aliaksei Tsitovich ◽  
Christoph M. Wintersteiger
Keyword(s):  
Model Checking ◽  
Static Analysis ◽  
Abstract Interpretation ◽  
C Programs ◽  
Run Time ◽  
Fix Point

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.

Model Checking of Distributed and Concurrent Systems

2017 ◽  
pp. 377-406
Author(s):  
Ivan Cibrario Bertolotti ◽  
Tingting Hu
Keyword(s):  
Model Checking ◽  
Concurrent Systems

scholarly journals Detecting Uninitialized Variables in C++ with the Clang Static Analyzer

2020 ◽  
Author(s):  
Kristóf Umann ◽  
Zoltán Porkoláb
Keyword(s):  
Software Engineering ◽  
Open Source ◽  
Programming Languages ◽  
Static Analysis ◽  
Common Source ◽  
Initial Value ◽  
Analysis Techniques ◽  
Specific Variable ◽  
Prototype Tool ◽  
Run Time

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.

Sign in / Sign up

Export Citation Format

Share Document