The central notion of this paper is that of contracts for concurrency, allowing one to capture the expected atomicity of sequences of method or service calls in a concurrent program. The contracts may be either extracted automatically from the source code, or provided by developers of libraries or software modules to reflect their expected usage in a concurrent setting. We start by extending the so-far considered notion of contracts for concurrency in several ways, improving their expressiveness and enhancing their applicability in practice. Then, we propose two complementary analyses - a static and a dynamic one - to verify programs against the extended contracts. We have implemented both approaches and present promising experimental results from their application on various programs, including real-world ones where our approach unveiled previously unknown errors.
The reliability of a network is a crucial requirement for applications and systems such as IoT (Internet-of-Things), cloud-based solutions, client-server, or peer-to-peer architectures. Unfortunately, real networks cannot be assumed to be fault-free, especially when considering various hardware problems, performance issues, or even malicious attacks. Testing network applications should include the evaluation of fault-tolerance of a system under various network conditions. The paper introduces a tool, NetLoiter, which helps developers and verification&validation practitioners easily analyse their network application’s behaviour in unexpected network situations. The tool is based on man-in-the-middle attacks and aims at network nodes communicating directly using a single network interface or indirectly via a single network active component (such as a switch or router). NetLoiter implements a fault-injection method; supported faults and attacks are inspired by the real world, including lossy channels, network jitter, data corruption, or disconnections.
Implementation of a pipeline-based execution of instructions in purpose-specific microprocessors is an error prone task, which implies a need of proper verification of the resulting design. Various techniques were proposed for this purpose, but they usually require a significant manual intervention of the developers. In this work, we propose a novel, highly automated approach for discovering RAW hazards in in-order pipelined instruction execution. Our approach combines static analysis of data paths to detect anomalies and possible hazards, followed by a transformation of detected problematic paths to a parameterised system (PS), and a subsequent formal verification to check the possibility of unhandled hazards using techniques for formal verification of PSs. We have implemented our approach and successfully applied it on multiple non-trivial microprocessors.
The paper proposes an automated approach with a formal basis designed for checking correspondence between an RTL implementation of a microprocessor and a description of its instruction set architecture (ISA). The goals of the approach are to find bugs not discovered by functional verification, to minimize user intervention in the verification process, and to provide a developer with practical results within a short period of time. The main idea is to use bounded model checking to check that the output produced by automatically derived RTL and ISA models of a given processor are the same for each instruction and each possible input. Although the approach does not provide full formal verification, experiments with the approach confirm that due to a different way it explores the state space of the design under test, it can find bugs not found by functional verification, and is thus a useful complement to functional verification.
13 December 2016 in Electronic Proceedings in Theoretical Computer Science
HADES is a fully automated verification tool for pipeline-based microprocessors that aims at flaws caused by improperly handled data hazards. It focuses on single-pipeline microprocessors designed at the register transfer level (RTL) and deals with read-after-write, write-after-write, and write-after-read hazards. HADES combines several techniques, including data-flow analysis, error pattern matching, SMT solving, and abstract regular model checking. It has been successfully tested on several microprocessors for embedded applications.Comment: In Proceedings MEMICS 2016, arXiv:1612.0403